fizzy-cli 0.2.1 → 0.4.0

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

@@ -41,7 +41,6 @@ func handleUpdateCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("API client not available")
 	}
 
-	// Validate that at least one field is provided for update
 	if updateTitle == "" && updateDescription == "" && updateStatus == "" && len(updateTagIDs) == 0 && updateLastActiveAt == "" {
 		return fmt.Errorf("must provide at least one flag to update (--title, --description, --status, --tag-id, or --last-active-at)")
 	}

package/cmd/card_update_test.go

@@ -49,7 +49,6 @@ func TestCardUpdateCommand(t *testing.T) {
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
 
-	// Reset flags to defaults
 	updateTitle = "Updated card title"
 	updateDescription = "Updated description"
 	updateStatus = "published"
@@ -130,7 +129,6 @@ func TestCardUpdateCommandNoFlags(t *testing.T) {
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
 
-	// Reset all flags
 	updateTitle = ""
 	updateDescription = ""
 	updateStatus = ""

package/cmd/card_watch.go

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

package/cmd/card_watch_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 TestCardWatchCommandSuccess(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.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 := cardWatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleWatchCard(cmd, "123"); err != nil {
+		t.Fatalf("handleWatchCard failed: %v", err)
+	}
+}
+
+func TestCardWatchCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardWatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleWatchCard(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 TestCardWatchCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardWatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleWatchCard(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 TestCardWatchCommandAPIError(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 := cardWatchCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleWatchCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "watching card: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/login.go

@@ -47,8 +47,9 @@ func handleLogin(cmd *cobra.Command) error {
 
 	fmt.Printf("\nSelected account: %s (%s)\n", selected.Name, selected.Slug)
 
-	// Save the selected account to config
+	// Save the selected account and current user ID to config
 	a.Config.SelectedAccount = selected.Slug
+	a.Config.CurrentUserID = selected.User.ID
 	if err := a.Config.Save(); err != nil {
 		return fmt.Errorf("saving config: %w", err)
 	}

package/cmd/notification.go

@@ -0,0 +1,14 @@
+// Package cmd
+package cmd
+
+import "github.com/spf13/cobra"
+
+var notificationCmd = &cobra.Command{
+	Use:   "notification",
+	Short: "Manage notifications",
+	Long:  `Manage notifications in Fizzy`,
+}
+
+func init() {
+	rootCmd.AddCommand(notificationCmd)
+}

package/cmd/notification_list.go

@@ -0,0 +1,69 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var notificationListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all notifications",
+	Long:  `Retrieve and display all notifications from Fizzy`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListNotifications(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListNotifications(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	notifications, err := a.Client.GetNotifications(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching notifications: %w", err)
+	}
+
+	read, _ := cmd.Flags().GetBool("read")
+	unread, _ := cmd.Flags().GetBool("unread")
+
+	filtered := filterNotifications(notifications, read, unread)
+
+	if len(filtered) == 0 {
+		fmt.Println("No notifications found")
+		return nil
+	}
+
+	return ui.DisplayNotifications(filtered)
+}
+
+func filterNotifications(notifications []api.Notification, read bool, unread bool) []api.Notification {
+	if !read && !unread {
+		return notifications
+	}
+
+	var filtered []api.Notification
+	for _, notification := range notifications {
+		if read && notification.Read {
+			filtered = append(filtered, notification)
+		} else if unread && !notification.Read {
+			filtered = append(filtered, notification)
+		}
+	}
+
+	return filtered
+}
+
+func init() {
+	notificationCmd.AddCommand(notificationListCmd)
+	notificationListCmd.Flags().BoolP("read", "r", false, "Show only read notifications")
+	notificationListCmd.Flags().BoolP("unread", "u", false, "Show only unread notifications")
+}