fizzy-cli 0.3.0 → 0.5.0

package/cmd/card_tag_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 TestCardTagCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/taggings" {
+			t.Errorf("expected /cards/123/taggings, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodPost {
+			t.Errorf("expected POST, 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 := cardTagCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleTagCard(cmd, "123", "bug"); err != nil {
+		t.Fatalf("handleTagCard failed: %v", err)
+	}
+}
+
+func TestCardTagCommandWithHashPrefix(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/456/taggings" {
+			t.Errorf("expected /cards/456/taggings, 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 := cardTagCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleTagCard(cmd, "456", "#feature"); err != nil {
+		t.Fatalf("handleTagCard with # prefix failed: %v", err)
+	}
+}
+
+func TestCardTagCommandAPIError(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 := cardTagCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleTagCard(cmd, "999", "bug")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "toggling tag on card: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardTagCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardTagCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleTagCard(cmd, "not-a-number", "bug")
+	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 TestCardTagCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardTagCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleTagCard(cmd, "123", "bug")
+	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/card_ungolden.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardUngoldenCmd = &cobra.Command{
+	Use:   "ungolden <card_number>",
+	Short: "Remove golden status from a card",
+	Long:  `Remove golden status from an existing card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUngoldenCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUngoldenCard(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")
+	}
+
+	_, err = a.Client.DeleteCardGoldenness(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("removing golden status: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d golden status removed\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardUngoldenCmd)
+}

package/cmd/card_ungolden_test.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardUngoldenCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/goldness" {
+			t.Errorf("expected /cards/123/goldness, 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 := cardUngoldenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleUngoldenCard(cmd, "123"); err != nil {
+		t.Fatalf("handleUngoldenCard failed: %v", err)
+	}
+}
+
+func TestCardUngoldenCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUngoldenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUngoldenCard(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 TestCardUngoldenCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUngoldenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUngoldenCard(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 TestCardUngoldenCommandAPIError(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 := cardUngoldenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUngoldenCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "removing golden status: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/card_untriage.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardUntriagedCmd = &cobra.Command{
+	Use:   "untriage <card_number>",
+	Short: "Send a card back to triage",
+	Long:  `Send an existing card back to the triage column`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUntriagedCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUntriagedCard(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")
+	}
+
+	_, err = a.Client.DeleteCardTriage(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("sending card back to triage: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d sent back to triage successfully\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardUntriagedCmd)
+}

package/cmd/card_untriage_test.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardUntriagedCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/triage" {
+			t.Errorf("expected /cards/123/triage, 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 := cardUntriagedCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleUntriagedCard(cmd, "123"); err != nil {
+		t.Fatalf("handleUntriagedCard failed: %v", err)
+	}
+}
+
+func TestCardUntriagedCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUntriagedCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUntriagedCard(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 TestCardUntriagedCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUntriagedCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUntriagedCard(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 TestCardUntriagedCommandAPIError(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 := cardUntriagedCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUntriagedCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "sending card back to triage: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/card_unwatch.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardUnwatchCmd = &cobra.Command{
+	Use:   "unwatch <card_number>",
+	Short: "Unsubscribe from card notifications",
+	Long:  `Unsubscribe from notifications for an existing card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUnwatchCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUnwatchCard(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")
+	}
+
+	_, err = a.Client.DeleteCardWatch(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("unwatching card: %w", err)
+	}
+
+	fmt.Printf("✓ Stopped watching card #%d\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardUnwatchCmd)
+}

package/cmd/card_unwatch_test.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardUnwatchCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/watch" {
+			t.Errorf("expected /cards/123/watch, 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 := cardUnwatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleUnwatchCard(cmd, "123"); err != nil {
+		t.Fatalf("handleUnwatchCard failed: %v", err)
+	}
+}
+
+func TestCardUnwatchCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUnwatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUnwatchCard(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 TestCardUnwatchCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUnwatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUnwatchCard(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 TestCardUnwatchCommandAPIError(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 := cardUnwatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUnwatchCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "unwatching card: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/card_update.go

@@ -10,14 +10,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var (
-	updateTitle        string
-	updateDescription  string
-	updateStatus       string
-	updateTagIDs       []string
-	updateLastActiveAt string
-)
-
 var cardUpdateCmd = &cobra.Command{
 	Use:   "update <card_number>",
 	Short: "Update a card",
@@ -41,16 +33,23 @@ func handleUpdateCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("API client not available")
 	}
 
-	if updateTitle == "" && updateDescription == "" && updateStatus == "" && len(updateTagIDs) == 0 && updateLastActiveAt == "" {
+	// Read flag values directly from command
+	title, _ := cmd.Flags().GetString("title")
+	description, _ := cmd.Flags().GetString("description")
+	status, _ := cmd.Flags().GetString("status")
+	tagIDs, _ := cmd.Flags().GetStringSlice("tag-id")
+	lastActiveAt, _ := cmd.Flags().GetString("last-active-at")
+
+	if title == "" && description == "" && status == "" && len(tagIDs) == 0 && lastActiveAt == "" {
 		return fmt.Errorf("must provide at least one flag to update (--title, --description, --status, --tag-id, or --last-active-at)")
 	}
 
 	payload := api.UpdateCardPayload{
-		Title:        updateTitle,
-		Description:  updateDescription,
-		Status:       updateStatus,
-		TagIDS:       updateTagIDs,
-		LastActiveAt: updateLastActiveAt,
+		Title:        title,
+		Description:  description,
+		Status:       status,
+		TagIDS:       tagIDs,
+		LastActiveAt: lastActiveAt,
 	}
 
 	card, err := a.Client.PutCard(context.Background(), cardNum, payload)
@@ -63,11 +62,11 @@ func handleUpdateCard(cmd *cobra.Command, cardNumber string) error {
 }
 
 func init() {
-	cardUpdateCmd.Flags().StringVarP(&updateTitle, "title", "t", "", "Card title")
-	cardUpdateCmd.Flags().StringVarP(&updateDescription, "description", "d", "", "Card description")
-	cardUpdateCmd.Flags().StringVar(&updateStatus, "status", "", "Card status")
-	cardUpdateCmd.Flags().StringSliceVar(&updateTagIDs, "tag-id", []string{}, "Tag ID (can be used multiple times)")
-	cardUpdateCmd.Flags().StringVar(&updateLastActiveAt, "last-active-at", "", "Last active timestamp")
+	cardUpdateCmd.Flags().StringP("title", "t", "", "Card title")
+	cardUpdateCmd.Flags().StringP("description", "d", "", "Card description")
+	cardUpdateCmd.Flags().String("status", "", "Card status")
+	cardUpdateCmd.Flags().StringSlice("tag-id", []string{}, "Tag ID (can be used multiple times)")
+	cardUpdateCmd.Flags().String("last-active-at", "", "Last active timestamp")
 
 	cardCmd.AddCommand(cardUpdateCmd)
 }

package/cmd/card_update_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/rogeriopvl/fizzy/internal/api"
 	"github.com/rogeriopvl/fizzy/internal/app"
 	"github.com/rogeriopvl/fizzy/internal/testutil"
+	"github.com/spf13/cobra"
 )
 
 func TestCardUpdateCommand(t *testing.T) {
@@ -48,11 +49,12 @@ func TestCardUpdateCommand(t *testing.T) {
 
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
-
-	updateTitle = "Updated card title"
-	updateDescription = "Updated description"
-	updateStatus = "published"
-	updateTagIDs = []string{"updated-tag"}
+	cmd.ParseFlags([]string{
+		"--title", "Updated card title",
+		"--description", "Updated description",
+		"--status", "published",
+		"--tag-id", "updated-tag",
+	})
 
 	if err := handleUpdateCard(cmd, "1"); err != nil {
 		t.Fatalf("handleUpdateCard failed: %v", err)
@@ -71,8 +73,9 @@ func TestCardUpdateCommandAPIError(t *testing.T) {
 
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
-
-	updateTitle = "Updated card"
+	cmd.ParseFlags([]string{
+		"--title", "Updated card",
+	})
 
 	err := handleUpdateCard(cmd, "999")
 	if err == nil {
@@ -88,8 +91,9 @@ func TestCardUpdateCommandNoClient(t *testing.T) {
 
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
-
-	updateTitle = "Updated card"
+	cmd.ParseFlags([]string{
+		"--title", "Updated card",
+	})
 
 	err := handleUpdateCard(cmd, "1")
 	if err == nil {
@@ -105,8 +109,9 @@ func TestCardUpdateCommandInvalidCardNumber(t *testing.T) {
 
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
-
-	updateTitle = "Updated card"
+	cmd.ParseFlags([]string{
+		"--title", "Updated card",
+	})
 
 	err := handleUpdateCard(cmd, "not-a-number")
 	if err == nil {
@@ -118,22 +123,21 @@ func TestCardUpdateCommandInvalidCardNumber(t *testing.T) {
 }
 
 func TestCardUpdateCommandNoFlags(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
 	testApp := &app.App{Client: client}
 
-	cmd := cardUpdateCmd
-	cmd.SetContext(testApp.ToContext(context.Background()))
+	// Create a fresh command to avoid flag pollution from other tests
+	cmd := &cobra.Command{
+		Use:  "update <card_number>",
+		Args: cobra.ExactArgs(1),
+	}
+	cmd.Flags().String("title", "", "Card title")
+	cmd.Flags().String("description", "", "Card description")
+	cmd.Flags().String("status", "", "Card status")
+	cmd.Flags().StringSlice("tag-id", []string{}, "Tag ID")
+	cmd.Flags().String("last-active-at", "", "Last active timestamp")
 
-	updateTitle = ""
-	updateDescription = ""
-	updateStatus = ""
-	updateTagIDs = []string{}
-	updateLastActiveAt = ""
+	cmd.SetContext(testApp.ToContext(context.Background()))
 
 	err := handleUpdateCard(cmd, "1")
 	if err == nil {