fizzy-cli 0.4.0 → 0.6.0

package/cmd/comment_update_test.go

@@ -0,0 +1,130 @@
+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"
+)
+
+func TestCommentUpdateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/comments/comment-456" {
+			t.Errorf("expected /cards/123/comments/comment-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)
+		}
+
+		if r.Header.Get("Content-Type") != "application/json" {
+			t.Errorf("expected Content-Type: application/json, got %s", r.Header.Get("Content-Type"))
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]string
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		commentPayload := payload["comment"]
+		if commentPayload["body"] != "Updated comment text" {
+			t.Errorf("expected body 'Updated comment text', got %s", commentPayload["body"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Comment{
+			ID:        "comment-456",
+			CreatedAt: "2025-01-01T00:00:00Z",
+			UpdatedAt: "2025-01-02T00:00:00Z",
+			Creator:   api.User{ID: "user-1", Name: "John Doe"},
+		}
+		response.Body.PlainText = "Updated comment text"
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := commentUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--body", "Updated comment text",
+	})
+
+	if err := handleUpdateComment(cmd, "123", "comment-456"); err != nil {
+		t.Fatalf("handleUpdateComment failed: %v", err)
+	}
+}
+
+func TestCommentUpdateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := commentUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--body", "Updated text",
+	})
+
+	err := handleUpdateComment(cmd, "not-a-number", "comment-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 TestCommentUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := commentUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--body", "Updated text",
+	})
+
+	err := handleUpdateComment(cmd, "123", "comment-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 TestCommentUpdateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Comment not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := commentUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--body", "Updated text",
+	})
+
+	err := handleUpdateComment(cmd, "123", "comment-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating comment: unexpected status code 404: Comment not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/reaction.go

@@ -0,0 +1,13 @@
+package cmd
+
+import "github.com/spf13/cobra"
+
+var reactionCmd = &cobra.Command{
+	Use:   "reaction",
+	Short: "Manage comment reactions",
+	Long:  `Manage reactions on comments in Fizzy`,
+}
+
+func init() {
+	rootCmd.AddCommand(reactionCmd)
+}

package/cmd/reaction_create.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var reactionCreateCmd = &cobra.Command{
+	Use:   "create <card_number> <comment_id> <emoji>",
+	Short: "Create a reaction on a comment",
+	Long:  `Create an emoji reaction on a comment`,
+	Args:  cobra.ExactArgs(3),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateReaction(cmd, args[0], args[1], args[2]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateReaction(cmd *cobra.Command, cardNumber, commentID, emoji 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")
+	}
+
+	reaction, err := a.Client.PostCommentReaction(context.Background(), cardNum, commentID, emoji)
+	if err != nil {
+		return fmt.Errorf("creating reaction: %w", err)
+	}
+
+	fmt.Printf("✓ Reaction %s created successfully (id: %s)\n", reaction.Content, reaction.ID)
+	return nil
+}
+
+func init() {
+	reactionCmd.AddCommand(reactionCreateCmd)
+}

package/cmd/reaction_create_test.go

@@ -0,0 +1,113 @@
+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"
+)
+
+func TestReactionCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/comments/comment-456/reactions" {
+			t.Errorf("expected /cards/123/comments/comment-456/reactions, 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)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]string
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		reactionPayload := payload["reaction"]
+		if reactionPayload["content"] != "👍" {
+			t.Errorf("expected content '👍', got %s", reactionPayload["content"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		response := api.Reaction{
+			ID:      "reaction-789",
+			Content: "👍",
+			Reacter: api.User{ID: "user-1", Name: "John Doe"},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := reactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleCreateReaction(cmd, "123", "comment-456", "👍"); err != nil {
+		t.Fatalf("handleCreateReaction failed: %v", err)
+	}
+}
+
+func TestReactionCreateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateReaction(cmd, "not-a-number", "comment-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 TestReactionCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateReaction(cmd, "123", "comment-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 TestReactionCreateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Comment not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := reactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateReaction(cmd, "123", "comment-456", "👍")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating reaction: unexpected status code 404: Comment not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/reaction_delete.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var reactionDeleteCmd = &cobra.Command{
+	Use:   "delete <card_number> <comment_id> <reaction_id>",
+	Short: "Delete a reaction from a comment",
+	Long:  `Delete an emoji reaction from a comment`,
+	Args:  cobra.ExactArgs(3),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeleteReaction(cmd, args[0], args[1], args[2]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeleteReaction(cmd *cobra.Command, cardNumber, commentID, reactionID 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.DeleteCommentReaction(context.Background(), cardNum, commentID, reactionID)
+	if err != nil {
+		return fmt.Errorf("deleting reaction: %w", err)
+	}
+
+	fmt.Printf("✓ Reaction deleted successfully\n")
+	return nil
+}
+
+func init() {
+	reactionCmd.AddCommand(reactionDeleteCmd)
+}

package/cmd/reaction_delete_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 TestReactionDeleteCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/comments/comment-456/reactions/reaction-789" {
+			t.Errorf("expected /cards/123/comments/comment-456/reactions/reaction-789, 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 := reactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteReaction(cmd, "123", "comment-456", "reaction-789"); err != nil {
+		t.Fatalf("handleDeleteReaction failed: %v", err)
+	}
+}
+
+func TestReactionDeleteCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteReaction(cmd, "not-a-number", "comment-456", "reaction-789")
+	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 TestReactionDeleteCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteReaction(cmd, "123", "comment-456", "reaction-789")
+	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 TestReactionDeleteCommandAPIError(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 := reactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteReaction(cmd, "123", "comment-456", "reaction-789")
+	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)
+	}
+}

package/cmd/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 reactionListCmd = &cobra.Command{
+	Use:   "list <card_number> <comment_id>",
+	Short: "List reactions on a comment",
+	Long:  `Retrieve and display all reactions on a comment`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListReactions(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListReactions(cmd *cobra.Command, cardNumber, commentID 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.GetCommentReactions(context.Background(), cardNum, commentID)
+	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() {
+	reactionCmd.AddCommand(reactionListCmd)
+}

package/cmd/reaction_list_test.go

@@ -0,0 +1,125 @@
+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 TestReactionListCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/comments/comment-456/reactions" {
+			t.Errorf("expected /cards/123/comments/comment-456/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")
+		response := []api.Reaction{
+			{
+				ID:      "reaction-1",
+				Content: "👍",
+				Reacter: api.User{ID: "user-1", Name: "John Doe"},
+			},
+			{
+				ID:      "reaction-2",
+				Content: "❤️",
+				Reacter: api.User{ID: "user-2", Name: "Jane Doe"},
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := reactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListReactions(cmd, "123", "comment-456"); err != nil {
+		t.Fatalf("handleListReactions failed: %v", err)
+	}
+}
+
+func TestReactionListCommandNoReactions(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.Reaction{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := reactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListReactions(cmd, "123", "comment-456"); err != nil {
+		t.Fatalf("handleListReactions failed: %v", err)
+	}
+}
+
+func TestReactionListCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListReactions(cmd, "not-a-number", "comment-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 TestReactionListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := reactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListReactions(cmd, "123", "comment-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 TestReactionListCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Comment not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := reactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListReactions(cmd, "123", "comment-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching reactions: unexpected status code 404: Comment not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/step.go

@@ -0,0 +1,14 @@
+// Package cmd
+package cmd
+
+import "github.com/spf13/cobra"
+
+var stepCmd = &cobra.Command{
+	Use:   "step",
+	Short: "Manage card steps",
+	Long:  `Manage steps (to-do items) on cards in Fizzy`,
+}
+
+func init() {
+	rootCmd.AddCommand(stepCmd)
+}

package/cmd/step_create.go

@@ -0,0 +1,53 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var stepCreateCmd = &cobra.Command{
+	Use:   "create <card_number>",
+	Short: "Create a new step",
+	Long:  `Create a new step (to-do item) on a card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateStep(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateStep(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")
+	}
+
+	content, _ := cmd.Flags().GetString("content")
+	completed, _ := cmd.Flags().GetBool("completed")
+
+	step, err := a.Client.PostCardStep(context.Background(), cardNum, content, completed)
+	if err != nil {
+		return fmt.Errorf("creating step: %w", err)
+	}
+
+	fmt.Printf("✓ Step created successfully (id: %s)\n", step.ID)
+	return nil
+}
+
+func init() {
+	stepCreateCmd.Flags().StringP("content", "c", "", "Step content (required)")
+	stepCreateCmd.MarkFlagRequired("content")
+	stepCreateCmd.Flags().BoolP("completed", "d", false, "Mark step as completed")
+
+	stepCmd.AddCommand(stepCreateCmd)
+}