fizzy-cli 0.1.0 → 0.2.0

package/cmd/column_list_test.go

@@ -0,0 +1,138 @@
+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 TestColumnListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123/columns" {
+			t.Errorf("expected /boards/board-123/columns, 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)
+		}
+
+		if r.Header.Get("Accept") != "application/json" {
+			t.Errorf("expected Accept: application/json, got %s", r.Header.Get("Accept"))
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := []api.Column{
+			{
+				ID:   "col-123",
+				Name: "Todo",
+				Color: api.ColorObject{
+					Name:  "Blue",
+					Value: "var(--color-card-default)",
+				},
+				CreatedAt: "2025-01-01T00:00:00Z",
+			},
+			{
+				ID:   "col-456",
+				Name: "In Progress",
+				Color: api.ColorObject{
+					Name:  "Lime",
+					Value: "var(--color-card-4)",
+				},
+				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}
+
+	cmd := columnListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListColumns(cmd); err != nil {
+		t.Fatalf("handleListColumns failed: %v", err)
+	}
+}
+
+func TestColumnListCommandNoColumns(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.Column{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListColumns(cmd); err != nil {
+		t.Fatalf("handleListColumns failed: %v", err)
+	}
+}
+
+func TestColumnListCommandAPIError(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}
+
+	cmd := columnListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListColumns(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching columns: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestColumnListCommandNoBoard(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListColumns(cmd)
+	if err == nil {
+		t.Errorf("expected error when board not selected")
+	}
+	if err.Error() != "fetching columns: please select a board first with 'fizzy use --board <board_name>'" {
+		t.Errorf("expected 'board not selected' error, got %v", err)
+	}
+}
+
+func TestColumnListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := columnListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListColumns(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/login.go

@@ -1,8 +1,13 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
+	"os"
 
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
 	"github.com/spf13/cobra"
 )
 
@@ -11,13 +16,65 @@ var loginCmd = &cobra.Command{
 	Short: "Prints instructions on how to authenticate with the Fizzy API",
 	Long:  `Prints intructions on how to authenticate with the Fizzy API`,
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("To authenticate with Fizzy's API you need an access token.")
-		fmt.Println("\nGo to https://app.fizzy.do/<account_slug>/my/access_tokens and follow the instructions...")
-		fmt.Println("(Replace <account_slug> with your account slug/id)")
-		fmt.Println("\nThen export it as an environment variable in your shell, with the name FIZZY_ACCESS_TOKEN")
+		if err := handleLogin(cmd); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		}
 	},
 }
 
+func handleLogin(cmd *cobra.Command) error {
+	token, isSet := os.LookupEnv("FIZZY_ACCESS_TOKEN")
+	if !isSet || token == "" {
+		return printAuthInstructions()
+	}
+
+	fmt.Printf("✓ Authenticated with access token: %s\n", token[:6]+"...")
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	identity, err := a.Client.GetMyIdentity(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching identity: %w", err)
+	}
+
+	selected, err := chooseAccount(identity.Accounts)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("\nSelected account: %s (%s)\n", selected.Name, selected.Slug)
+
+	// Save the selected account to config
+	a.Config.SelectedAccount = selected.Slug
+	if err := a.Config.Save(); err != nil {
+		return fmt.Errorf("saving config: %w", err)
+	}
+
+	return nil
+}
+
+func chooseAccount(accounts []api.Account) (api.Account, error) {
+	if len(accounts) == 1 {
+		selected := accounts[0]
+		return selected, nil
+	}
+
+	fmt.Println("\nAvailable accounts:")
+	return ui.SelectAccount(accounts)
+}
+
+func printAuthInstructions() error {
+	fmt.Println("To authenticate with Fizzy's API you need an access token.")
+	fmt.Printf("\nGo to https://app.fizzy.do/<account_slug>/my/access_tokens and follow the instructions...\n")
+	fmt.Println("(Replace <account_slug> with your account slug)")
+	fmt.Printf("\nThen export it as an environment variable in your shell, with the name FIZZY_ACCESS_TOKEN\n")
+	fmt.Println("And re-run this command.")
+	return nil
+}
+
 func init() {
 	rootCmd.AddCommand(loginCmd)
 }

package/cmd/login_test.go

@@ -0,0 +1,98 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"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 TestLoginCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/my/identity" {
+			t.Errorf("expected /my/identity, 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")
+			w.WriteHeader(http.StatusUnauthorized)
+			return
+		}
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		if r.Header.Get("Accept") != "application/json" {
+			t.Errorf("expected Accept: application/json, got %s", r.Header.Get("Accept"))
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.GetMyIdentityResponse{
+			Accounts: []api.Account{
+				{
+					ID:   "acc-123",
+					Name: "Test Account",
+					Slug: "test-account",
+					User: api.User{
+						ID:    "user-123",
+						Email: "test@example.com",
+						Name:  "Test User",
+					},
+				},
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	tmpDir := t.TempDir()
+	configPath := tmpDir + "/.config/fizzy-cli/config.json"
+
+	t.Setenv("FIZZY_ACCESS_TOKEN", "test-token")
+	t.Setenv("HOME", tmpDir)
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+
+	cfg := &config.Config{}
+	testApp := &app.App{
+		Client: client,
+		Config: cfg,
+	}
+
+	cmd := loginCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleLogin(cmd); err != nil {
+		t.Fatalf("handleLogin failed: %v", err)
+	}
+
+	if cfg.SelectedAccount != "test-account" {
+		t.Errorf("expected SelectedAccount=test-account, got %s", cfg.SelectedAccount)
+	}
+
+	if _, err := os.Stat(configPath); err != nil {
+		t.Errorf("config file not created at %s: %v", configPath, err)
+	}
+}
+
+func TestLoginCommandWithoutToken(t *testing.T) {
+	t.Setenv("FIZZY_ACCESS_TOKEN", "")
+
+	cmd := loginCmd
+	err := handleLogin(cmd)
+
+	if err != nil {
+		t.Errorf("expected no error when token is missing, got %v", err)
+	}
+}

package/cmd/root.go

@@ -1,16 +1,26 @@
 package cmd
 
 import (
+	"fmt"
 	"os"
 
+	"github.com/rogeriopvl/fizzy/internal/app"
 	"github.com/spf13/cobra"
 )
 
+var Version = "dev"
+
 var rootCmd = &cobra.Command{
-	Use:   "fizzy-cli",
-	Short: "Fizzy CLI",
-	Long:  `Fizzy CLI`,
-	// Run: func(cmd *cobra.Command, args []string) { },
+	Use:     "fizzy-cli",
+	Short:   "Fizzy CLI",
+	Long:    `Fizzy CLI`,
+	Version: Version,
+	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		a, _ := app.New()
+		if a != nil {
+			cmd.SetContext(a.ToContext(cmd.Context()))
+		}
+	},
 }
 
 func Execute() {
@@ -24,4 +34,5 @@ func init() {
 	// rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.fizzy-cli.yaml)")
 
 	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	rootCmd.SetVersionTemplate(fmt.Sprintf("fizzy-cli v%s\n", Version))
 }

package/cmd/use.go

@@ -0,0 +1,85 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var useCmd = &cobra.Command{
+	Use:   "use",
+	Short: "Set the active board or account",
+	Long:  `Set the active board or account to use for subsequent commands`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUse(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUse(cmd *cobra.Command) error {
+	board, _ := cmd.Flags().GetString("board")
+	account, _ := cmd.Flags().GetString("account")
+
+	if board == "" && account == "" {
+		return fmt.Errorf("must specify either --board or --account")
+	}
+
+	if board != "" && account != "" {
+		return fmt.Errorf("cannot specify both --board and --account")
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		return fmt.Errorf("loading config: %w", err)
+	}
+
+	if board != "" {
+		a := app.FromContext(cmd.Context())
+		if a == nil || a.Client == nil {
+			return fmt.Errorf("API client not available")
+		}
+
+		boards, err := a.Client.GetBoards(context.Background())
+		if err != nil {
+			return fmt.Errorf("fetching boards: %w", err)
+		}
+
+		var boardID string
+		for _, b := range boards {
+			if b.Name == board {
+				boardID = b.ID
+				break
+			}
+		}
+
+		if boardID == "" {
+			return fmt.Errorf("board '%s' not found", board)
+		}
+
+		cfg.SelectedBoard = boardID
+		if err := cfg.Save(); err != nil {
+			return fmt.Errorf("saving config: %w", err)
+		}
+		fmt.Printf("Selected board: %s\n", board)
+	}
+
+	if account != "" {
+		cfg.SelectedAccount = account
+		if err := cfg.Save(); err != nil {
+			return fmt.Errorf("saving config: %w", err)
+		}
+		fmt.Printf("Selected account: %s\n", account)
+	}
+
+	return nil
+}
+
+func init() {
+	rootCmd.AddCommand(useCmd)
+	useCmd.Flags().String("board", "", "Board name to use")
+	useCmd.Flags().String("account", "", "Account slug to use")
+}

package/cmd/use_test.go

@@ -0,0 +1,186 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"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"
+	"github.com/spf13/cobra"
+)
+
+func newUseCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "use",
+		Short: "Set the active board or account",
+		Long:  `Set the active board or account to use for subsequent commands`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := handleUse(cmd); err != nil {
+				fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+			}
+		},
+	}
+	cmd.Flags().String("board", "", "Board name to use")
+	cmd.Flags().String("account", "", "Account slug to use")
+	return cmd
+}
+
+func TestUseCommandSetBoard(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: "My Project",
+			},
+			{
+				ID:   "board-456",
+				Name: "Other Board",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	cfg := &config.Config{}
+	testApp := &app.App{
+		Client: client,
+		Config: cfg,
+	}
+
+	cmd := newUseCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--board", "My Project"})
+
+	if err := handleUse(cmd); err != nil {
+		t.Fatalf("handleUse failed: %v", err)
+	}
+
+	savedCfg, err := config.Load()
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+
+	if savedCfg.SelectedBoard != "board-123" {
+		t.Errorf("expected SelectedBoard=board-123, got %s", savedCfg.SelectedBoard)
+	}
+}
+
+func TestUseCommandSetAccount(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	cmd := newUseCmd()
+	cmd.ParseFlags([]string{"--account", "my-company"})
+
+	cfg := &config.Config{}
+	testApp := &app.App{Config: cfg}
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleUse(cmd); err != nil {
+		t.Fatalf("handleUse failed: %v", err)
+	}
+
+	savedCfg, err := config.Load()
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+
+	if savedCfg.SelectedAccount != "my-company" {
+		t.Errorf("expected SelectedAccount=my-company, got %s", savedCfg.SelectedAccount)
+	}
+}
+
+func TestUseCommandBoardNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		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.Board{
+			{ID: "board-123", Name: "Existing Board"},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	tmpDir := t.TempDir()
+	t.Setenv("HOME", tmpDir)
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{},
+	}
+
+	cmd := newUseCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--board", "Nonexistent Board"})
+
+	err := handleUse(cmd)
+	if err == nil {
+		t.Errorf("expected error for nonexistent board")
+	}
+	if err.Error() != "board 'Nonexistent Board' not found" {
+		t.Errorf("expected 'not found' error, got %v", err)
+	}
+}
+
+func TestUseCommandBothFlagsError(t *testing.T) {
+	cmd := newUseCmd()
+	cmd.ParseFlags([]string{"--board", "Board", "--account", "Account"})
+	cmd.SetContext(context.Background())
+
+	err := handleUse(cmd)
+	if err == nil {
+		t.Errorf("expected error when both flags provided")
+	}
+	if err.Error() != "cannot specify both --board and --account" {
+		t.Errorf("expected 'both flags' error, got %v", err)
+	}
+}
+
+func TestUseCommandNoFlagsError(t *testing.T) {
+	cmd := newUseCmd()
+	cmd.SetContext(context.Background())
+	cmd.ParseFlags([]string{})
+
+	err := handleUse(cmd)
+	if err == nil {
+		t.Errorf("expected error when no flags provided")
+	}
+	if err.Error() != "must specify either --board or --account" {
+		t.Errorf("expected 'no flags' error, got %v", err)
+	}
+}