fizzy-cli 0.4.0 → 0.6.0

package/cmd/step_create_test.go

@@ -0,0 +1,171 @@
+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 TestStepCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/steps" {
+			t.Errorf("expected /cards/123/steps, 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]map[string]any
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		stepPayload := payload["step"]
+		if stepPayload["content"] != "Write tests" {
+			t.Errorf("expected content 'Write tests', got %v", stepPayload["content"])
+		}
+		if stepPayload["completed"] != false {
+			t.Errorf("expected completed false, got %v", stepPayload["completed"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		response := api.Step{
+			ID:        "step-789",
+			Content:   "Write tests",
+			Completed: false,
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Write tests",
+	})
+
+	if err := handleCreateStep(cmd, "123"); err != nil {
+		t.Fatalf("handleCreateStep failed: %v", err)
+	}
+}
+
+func TestStepCreateCommandWithCompleted(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]any
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		stepPayload := payload["step"]
+		if stepPayload["completed"] != true {
+			t.Errorf("expected completed true, got %v", stepPayload["completed"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		response := api.Step{
+			ID:        "step-789",
+			Content:   "Already done",
+			Completed: true,
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Already done",
+		"--completed",
+	})
+
+	if err := handleCreateStep(cmd, "123"); err != nil {
+		t.Fatalf("handleCreateStep failed: %v", err)
+	}
+}
+
+func TestStepCreateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Test step",
+	})
+
+	err := handleCreateStep(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 TestStepCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Test step",
+	})
+
+	err := handleCreateStep(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 TestStepCreateCommandAPIError(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 := stepCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Test step",
+	})
+
+	err := handleCreateStep(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating step: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/step_delete.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var stepDeleteCmd = &cobra.Command{
+	Use:   "delete <card_number> <step_id>",
+	Short: "Delete a step",
+	Long:  `Delete a step from a card`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeleteStep(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeleteStep(cmd *cobra.Command, cardNumber, stepID 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.DeleteCardStep(context.Background(), cardNum, stepID)
+	if err != nil {
+		return fmt.Errorf("deleting step: %w", err)
+	}
+
+	fmt.Printf("✓ Step deleted successfully\n")
+	return nil
+}
+
+func init() {
+	stepCmd.AddCommand(stepDeleteCmd)
+}

package/cmd/step_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 TestStepDeleteCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/steps/step-456" {
+			t.Errorf("expected /cards/123/steps/step-456, 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 := stepDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteStep(cmd, "123", "step-456"); err != nil {
+		t.Fatalf("handleDeleteStep failed: %v", err)
+	}
+}
+
+func TestStepDeleteCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteStep(cmd, "not-a-number", "step-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 TestStepDeleteCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteStep(cmd, "123", "step-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 TestStepDeleteCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Step not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteStep(cmd, "123", "step-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "deleting step: unexpected status code 404: Step not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/step_update.go

@@ -0,0 +1,66 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var stepUpdateCmd = &cobra.Command{
+	Use:   "update <card_number> <step_id>",
+	Short: "Update an existing step",
+	Long:  `Update the content or completion status of an existing step on a card`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUpdateStep(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUpdateStep(cmd *cobra.Command, cardNumber, stepID 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")
+	}
+
+	var contentPtr *string
+	var completedPtr *bool
+
+	if cmd.Flags().Changed("content") {
+		content, _ := cmd.Flags().GetString("content")
+		contentPtr = &content
+	}
+
+	if cmd.Flags().Changed("completed") {
+		completed, _ := cmd.Flags().GetBool("completed")
+		completedPtr = &completed
+	}
+
+	if contentPtr == nil && completedPtr == nil {
+		return fmt.Errorf("at least one of --content or --completed must be provided")
+	}
+
+	step, err := a.Client.PutCardStep(context.Background(), cardNum, stepID, contentPtr, completedPtr)
+	if err != nil {
+		return fmt.Errorf("updating step: %w", err)
+	}
+
+	fmt.Printf("✓ Step updated successfully (id: %s)\n", step.ID)
+	return nil
+}
+
+func init() {
+	stepUpdateCmd.Flags().StringP("content", "c", "", "New step content")
+	stepUpdateCmd.Flags().BoolP("completed", "d", false, "Mark step as completed")
+
+	stepCmd.AddCommand(stepUpdateCmd)
+}

package/cmd/step_update_test.go

@@ -0,0 +1,190 @@
+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"
+	"github.com/spf13/cobra"
+)
+
+func TestStepUpdateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/steps/step-456" {
+			t.Errorf("expected /cards/123/steps/step-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]any
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		stepPayload := payload["step"]
+		if stepPayload["content"] != "Updated step text" {
+			t.Errorf("expected content 'Updated step text', got %v", stepPayload["content"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Step{
+			ID:        "step-456",
+			Content:   "Updated step text",
+			Completed: false,
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Updated step text",
+	})
+
+	if err := handleUpdateStep(cmd, "123", "step-456"); err != nil {
+		t.Fatalf("handleUpdateStep failed: %v", err)
+	}
+}
+
+func TestStepUpdateCommandWithCompleted(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]any
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		stepPayload := payload["step"]
+		if stepPayload["completed"] != true {
+			t.Errorf("expected completed true, got %v", stepPayload["completed"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Step{
+			ID:        "step-456",
+			Content:   "Some step",
+			Completed: true,
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--completed",
+	})
+
+	if err := handleUpdateStep(cmd, "123", "step-456"); err != nil {
+		t.Fatalf("handleUpdateStep failed: %v", err)
+	}
+}
+
+func TestStepUpdateCommandNoFlags(t *testing.T) {
+	testApp := &app.App{Client: testutil.NewTestClient("http://localhost", "", "", "test-token")}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	// Reset flags to ensure no flags are set
+	cmd.Flags().Set("content", "")
+	cmd.Flags().Set("completed", "false")
+
+	// Create a fresh command to avoid flag state from other tests
+	freshCmd := &cobra.Command{}
+	freshCmd.Flags().StringP("content", "c", "", "New step content")
+	freshCmd.Flags().BoolP("completed", "d", false, "Mark step as completed")
+	freshCmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUpdateStep(freshCmd, "123", "step-456")
+	if err == nil {
+		t.Errorf("expected error when no flags provided")
+	}
+	if err.Error() != "at least one of --content or --completed must be provided" {
+		t.Errorf("expected 'at least one flag' error, got %v", err)
+	}
+}
+
+func TestStepUpdateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Updated text",
+	})
+
+	err := handleUpdateStep(cmd, "not-a-number", "step-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 TestStepUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Updated text",
+	})
+
+	err := handleUpdateStep(cmd, "123", "step-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 TestStepUpdateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Step not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := stepUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--content", "Updated text",
+	})
+
+	err := handleUpdateStep(cmd, "123", "step-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating step: unexpected status code 404: Step not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/internal/api/boards.go

@@ -0,0 +1,59 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+func (c *Client) GetBoards(ctx context.Context) ([]Board, error) {
+	endpointURL := c.AccountBaseURL + "/boards"
+
+	req, err := c.newRequest(ctx, http.MethodGet, endpointURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	var response []Board
+	_, err = c.decodeResponse(req, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return response, nil
+}
+
+func (c *Client) GetBoard(ctx context.Context, boardID string) (*Board, error) {
+	endpointURL := c.AccountBaseURL + "/boards/" + boardID
+
+	req, err := c.newRequest(ctx, http.MethodGet, endpointURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	var response Board
+	_, err = c.decodeResponse(req, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}
+
+func (c *Client) PostBoards(ctx context.Context, payload CreateBoardPayload) (bool, error) {
+	endpointURL := c.AccountBaseURL + "/boards"
+
+	body := map[string]CreateBoardPayload{"board": payload}
+
+	req, err := c.newRequest(ctx, http.MethodPost, endpointURL, body)
+	if err != nil {
+		return false, fmt.Errorf("failed to create board request: %w", err)
+	}
+
+	_, err = c.decodeResponse(req, nil, http.StatusCreated)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}