fizzy-cli 0.1.0 → 0.2.0

package/cmd/card_create_test.go

@@ -0,0 +1,206 @@
+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/config"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123/cards" {
+			t.Errorf("expected /boards/board-123/cards, 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)
+		}
+
+		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]api.CreateCardPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		cardPayload := payload["card"]
+		if cardPayload.Title != "Implement feature" {
+			t.Errorf("expected title 'Implement feature', got %s", cardPayload.Title)
+		}
+		if cardPayload.Description != "A detailed description" {
+			t.Errorf("expected description 'A detailed description', got %s", cardPayload.Description)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cardTitle = "Implement feature"
+	cardDescription = "A detailed description"
+	cardStatus = ""
+	cardImageURL = ""
+	cardTagIDs = []string{}
+	cardCreatedAt = ""
+	cardLastActiveAt = ""
+
+	if err := handleCreateCard(cmd); err != nil {
+		t.Fatalf("handleCreateCard failed: %v", err)
+	}
+}
+
+func TestCardCreateCommandWithAllFields(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Errorf("expected POST, got %s", r.Method)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.CreateCardPayload
+		json.Unmarshal(body, &payload)
+
+		cardPayload := payload["card"]
+		if cardPayload.Title != "Fix bug" {
+			t.Errorf("expected title 'Fix bug', got %s", cardPayload.Title)
+		}
+		if cardPayload.Status != "in_progress" {
+			t.Errorf("expected status 'in_progress', got %s", cardPayload.Status)
+		}
+		if cardPayload.ImageURL != "https://example.com/image.jpg" {
+			t.Errorf("expected image URL 'https://example.com/image.jpg', got %s", cardPayload.ImageURL)
+		}
+		if len(cardPayload.TagIDS) != 2 || cardPayload.TagIDS[0] != "tag-1" || cardPayload.TagIDS[1] != "tag-2" {
+			t.Errorf("expected tag IDs [tag-1, tag-2], got %v", cardPayload.TagIDS)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cardTitle = "Fix bug"
+	cardDescription = ""
+	cardStatus = "in_progress"
+	cardImageURL = "https://example.com/image.jpg"
+	cardTagIDs = []string{"tag-1", "tag-2"}
+	cardCreatedAt = ""
+	cardLastActiveAt = ""
+
+	if err := handleCreateCard(cmd); err != nil {
+		t.Fatalf("handleCreateCard failed: %v", err)
+	}
+}
+
+func TestCardCreateCommandNoBoard(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: ""},
+	}
+
+	cmd := cardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cardTitle = "Test"
+	cardDescription = ""
+	cardStatus = ""
+	cardImageURL = ""
+	cardTagIDs = []string{}
+	cardCreatedAt = ""
+	cardLastActiveAt = ""
+
+	err := handleCreateCard(cmd)
+	if err == nil {
+		t.Errorf("expected error when board not selected")
+	}
+	if err.Error() != "no board selected" {
+		t.Errorf("expected 'no board selected' error, got %v", err)
+	}
+}
+
+func TestCardCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cardTitle = "Test"
+	cardDescription = ""
+	cardStatus = ""
+	cardImageURL = ""
+	cardTagIDs = []string{}
+	cardCreatedAt = ""
+	cardLastActiveAt = ""
+
+	err := handleCreateCard(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)
+	}
+}
+
+func TestCardCreateCommandAPIError(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,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cardTitle = "Test"
+	cardDescription = ""
+	cardStatus = ""
+	cardImageURL = ""
+	cardTagIDs = []string{}
+	cardCreatedAt = ""
+	cardLastActiveAt = ""
+
+	err := handleCreateCard(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating card: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/card_delete.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardDeleteCmd = &cobra.Command{
+	Use:   "delete <card_number>",
+	Short: "Delete a card",
+	Long:  `Delete an existing card permanently`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeleteCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeleteCard(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.DeleteCard(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("deleting card: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d deleted successfully\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardDeleteCmd)
+}

package/cmd/card_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 TestCardDeleteCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/1" {
+			t.Errorf("expected /cards/1, 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 := cardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteCard(cmd, "1"); err != nil {
+		t.Fatalf("handleDeleteCard failed: %v", err)
+	}
+}
+
+func TestCardDeleteCommandAPIError(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 := cardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCard(cmd, "999")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "deleting card: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardDeleteCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCard(cmd, "1")
+	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 TestCardDeleteCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCard(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)
+	}
+}

package/cmd/card_list.go

@@ -0,0 +1,53 @@
+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 cardListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all cards",
+	Long:  `Retrieve and display all cards from Fizzy`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListCards(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListCards(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	if a.Config.SelectedBoard == "" {
+		return fmt.Errorf("no board selected")
+	}
+
+	filters := api.CardFilters{
+		BoardIDs: []string{a.Config.SelectedBoard},
+	}
+
+	cards, err := a.Client.GetCards(context.Background(), filters)
+	if err != nil {
+		return fmt.Errorf("fetching cards: %w", err)
+	}
+
+	if len(cards) == 0 {
+		fmt.Println("No cards found")
+		return nil
+	}
+
+	return ui.DisplayCards(cards)
+}
+
+func init() {
+	cardCmd.AddCommand(cardListCmd)
+}

package/cmd/card_list_test.go

@@ -0,0 +1,148 @@
+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/config"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards" {
+			t.Errorf("expected /cards, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodGet {
+			t.Errorf("expected GET, got %s", r.Method)
+		}
+
+		boardIDs := r.URL.Query()["board_ids[]"]
+		if len(boardIDs) == 0 || boardIDs[0] != "board-123" {
+			t.Errorf("expected board_ids[]=board-123 in query, got %v", boardIDs)
+		}
+
+		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.Card{
+			{
+				ID:        "card-123",
+				Number:    1,
+				Title:     "Implement feature",
+				Status:    "in_progress",
+				CreatedAt: "2025-01-01T00:00:00Z",
+			},
+			{
+				ID:        "card-456",
+				Number:    2,
+				Title:     "Fix bug",
+				Status:    "todo",
+				CreatedAt: "2025-01-02T00:00:00Z",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandNoCards(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.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandAPIError(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,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := cardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCards(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching cards: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardListCommandNoBoard(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: ""},
+	}
+
+	cmd := cardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCards(cmd)
+	if err == nil {
+		t.Errorf("expected error when board not selected")
+	}
+	if err.Error() != "no board selected" {
+		t.Errorf("expected 'no board selected' error, got %v", err)
+	}
+}
+
+func TestCardListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCards(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/card_reopen.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardReopenCmd = &cobra.Command{
+	Use:   "reopen <card_number>",
+	Short: "Reopen a card",
+	Long:  `Reopen an existing closed card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleReopenCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleReopenCard(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.DeleteCardsClosure(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("reopening card: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d reopened successfully\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardReopenCmd)
+}

package/cmd/card_reopen_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 TestCardReopenCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/closure" {
+			t.Errorf("expected /cards/123/closure, 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 := cardReopenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleReopenCard(cmd, "123"); err != nil {
+		t.Fatalf("handleReopenCard failed: %v", err)
+	}
+}
+
+func TestCardReopenCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReopenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleReopenCard(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 TestCardReopenCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReopenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleReopenCard(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 TestCardReopenCommandAPIError(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 := cardReopenCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleReopenCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "reopening card: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}