fizzy-cli 0.1.0 → 0.2.1

package/cmd/board_create_test.go

@@ -0,0 +1,158 @@
+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 TestBoardCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards" {
+			t.Errorf("expected /boards, 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.CreateBoardPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		boardPayload := payload["board"]
+		if boardPayload.Name != "Test Board" {
+			t.Errorf("expected name 'Test Board', got %s", boardPayload.Name)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+		w.Header().Set("Location", "/boards/board-123")
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Test Board"})
+
+	boardName = "Test Board"
+	boardAllAccess = false
+	boardAutoPostponePeriod = 0
+	boardPublicDescription = ""
+
+	if err := handleCreateBoard(cmd); err != nil {
+		t.Fatalf("handleCreateBoard failed: %v", err)
+	}
+}
+
+func TestBoardCreateCommandWithAllFlags(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.CreateBoardPayload
+		json.Unmarshal(body, &payload)
+
+		boardPayload := payload["board"]
+		if !boardPayload.AllAccess {
+			t.Error("expected AllAccess to be true")
+		}
+		if boardPayload.AutoPostponePeriod != 7 {
+			t.Errorf("expected AutoPostponePeriod 7, got %d", boardPayload.AutoPostponePeriod)
+		}
+		if boardPayload.PublicDescription != "Team project" {
+			t.Errorf("expected description 'Team project', got %s", boardPayload.PublicDescription)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--name", "Test Board",
+		"--all-access",
+		"--auto-postpone-period", "7",
+		"--description", "Team project",
+	})
+
+	boardName = "Test Board"
+	boardAllAccess = true
+	boardAutoPostponePeriod = 7
+	boardPublicDescription = "Team project"
+
+	if err := handleCreateBoard(cmd); err != nil {
+		t.Fatalf("handleCreateBoard failed: %v", err)
+	}
+}
+
+func TestBoardCreateCommandAPIError(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 := boardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Test Board"})
+
+	boardName = "Test Board"
+	boardAllAccess = false
+	boardAutoPostponePeriod = 0
+	boardPublicDescription = ""
+
+	err := handleCreateBoard(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating board: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestBoardCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := boardCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Test Board"})
+
+	boardName = "Test Board"
+
+	err := handleCreateBoard(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/board_list.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
 	"github.com/spf13/cobra"
 )
 
@@ -11,46 +13,30 @@ var boardListCmd = &cobra.Command{
 	Use:   "list",
 	Short: "List all boards",
 	Long:  `Retrieve and display all boards from Fizzy`,
-	RunE:  listBoards,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListBoards(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
 }
 
-func listBoards(cmd *cobra.Command, args []string) error {
-	ctx := context.Background()
-
-	// TODO: Implement API call to fetch boards
-	boards, err := fetchBoards(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to list boards: %w", err)
+func handleListBoards(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
 	}
 
-	// TODO: Format and display boards
-	if err := displayBoards(boards); err != nil {
-		return fmt.Errorf("failed to display boards: %w", err)
+	boards, err := a.Client.GetBoards(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching boards: %w", err)
 	}
 
-	return nil
-}
-
-// fetchBoards retrieves all boards from the Fizzy API.
-func fetchBoards(ctx context.Context) ([]Board, error) {
-	// TODO: Implement API call
-	return nil, nil
-}
-
-// displayBoards formats and outputs the boards.
-func displayBoards(boards []Board) error {
-	// TODO: Implement output formatting
-	for _, board := range boards {
-		fmt.Printf("Board: %+v\n", board)
+	if len(boards) == 0 {
+		fmt.Println("No boards found")
+		return nil
 	}
-	return nil
-}
 
-// Board represents a Fizzy board.
-type Board struct {
-	ID   string
-	Name string
-	// TODO: Add additional fields as needed
+	return ui.DisplayBoards(boards)
 }
 
 func init() {

package/cmd/board_list_test.go

@@ -0,0 +1,115 @@
+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 TestBoardListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards" {
+			t.Errorf("expected /boards, 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 == "" {
+			t.Error("missing Authorization header")
+		}
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := []api.Board{
+			{
+				ID:        "board-123",
+				Name:      "Project Alpha",
+				AllAccess: true,
+				CreatedAt: "2025-01-01T00:00:00Z",
+			},
+			{
+				ID:        "board-456",
+				Name:      "Project Beta",
+				AllAccess: false,
+				CreatedAt: "2025-01-02T00:00:00Z",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListBoards(cmd); err != nil {
+		t.Fatalf("handleListBoards failed: %v", err)
+	}
+}
+
+func TestBoardListCommandNoBoards(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.Board{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListBoards(cmd); err != nil {
+		t.Fatalf("handleListBoards failed: %v", err)
+	}
+}
+
+func TestBoardListCommandAPIError(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 := boardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListBoards(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching boards: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestBoardListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := boardListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListBoards(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/board_test.go

@@ -0,0 +1,92 @@
+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 TestBoardCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123" {
+			t.Errorf("expected /boards/board-123, got %s", r.URL.Path)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Board{
+			ID:        "board-123",
+			Name:      "Test Board",
+			AllAccess: true,
+			CreatedAt: "2025-12-05T19:36:35.534Z",
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{
+			SelectedBoard: "board-123",
+		},
+	}
+
+	cmd := boardCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleShowBoard(cmd); err != nil {
+		t.Fatalf("handleShowBoard failed: %v", err)
+	}
+}
+
+func TestBoardCommandNoBoard(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{
+			SelectedBoard: "",
+		},
+	}
+
+	cmd := boardCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowBoard(cmd)
+	if err == nil {
+		t.Errorf("expected error when no board selected")
+	}
+	if err.Error() != "no board selected" {
+		t.Errorf("expected 'no board selected' error, got %v", err)
+	}
+}
+
+func TestBoardCommandAPIError(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,
+		Config: &config.Config{
+			SelectedBoard: "board-123",
+		},
+	}
+
+	cmd := boardCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowBoard(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+}

package/cmd/card.go

@@ -0,0 +1,24 @@
+// Package cmd
+package cmd
+
+import "github.com/spf13/cobra"
+
+var cardCmd = &cobra.Command{
+	Use:   "card",
+	Short: "Manage cards",
+	Long:  `Manage cards in Fizzy`,
+}
+
+func init() {
+	rootCmd.AddCommand(cardCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// cardsCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// cardsCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}

package/cmd/card_close.go

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

package/cmd/card_close_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 TestCardCloseCommandSuccess(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.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 := cardCloseCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleCloseCard(cmd, "123"); err != nil {
+		t.Fatalf("handleCloseCard failed: %v", err)
+	}
+}
+
+func TestCardCloseCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardCloseCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCloseCard(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 TestCardCloseCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardCloseCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCloseCard(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 TestCardCloseCommandAPIError(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 := cardCloseCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCloseCard(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "closing card: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/card_create.go

@@ -0,0 +1,73 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var (
+	cardTitle        string
+	cardDescription  string
+	cardStatus       string
+	cardImageURL     string
+	cardTagIDs       []string
+	cardCreatedAt    string
+	cardLastActiveAt string
+)
+
+var cardCreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a new card",
+	Long:  `Create a new card in the selected board`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateCard(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateCard(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")
+	}
+
+	payload := api.CreateCardPayload{
+		Title:        cardTitle,
+		Description:  cardDescription,
+		Status:       cardStatus,
+		ImageURL:     cardImageURL,
+		TagIDS:       cardTagIDs,
+		CreatedAt:    cardCreatedAt,
+		LastActiveAt: cardLastActiveAt,
+	}
+
+	_, err := a.Client.PostCards(context.Background(), payload)
+	if err != nil {
+		return fmt.Errorf("creating card: %w", err)
+	}
+
+	fmt.Printf("✓ Card '%s' created successfully\n", cardTitle)
+	return nil
+}
+
+func init() {
+	cardCreateCmd.Flags().StringVarP(&cardTitle, "title", "t", "", "Card title (required)")
+	cardCreateCmd.MarkFlagRequired("title")
+	cardCreateCmd.Flags().StringVarP(&cardDescription, "description", "d", "", "Card description")
+	cardCreateCmd.Flags().StringVar(&cardStatus, "status", "", "Card status")
+	cardCreateCmd.Flags().StringVar(&cardImageURL, "image-url", "", "Card image URL")
+	cardCreateCmd.Flags().StringSliceVar(&cardTagIDs, "tag-id", []string{}, "Tag ID (can be used multiple times)")
+	cardCreateCmd.Flags().StringVar(&cardCreatedAt, "created-at", "", "Creation timestamp")
+	cardCreateCmd.Flags().StringVar(&cardLastActiveAt, "last-active-at", "", "Last active timestamp")
+
+	cardCmd.AddCommand(cardCreateCmd)
+}