test: improved test coverage to above 80%

Author: jingle2008

internal/cli/root.go

@@ -172,17 +172,17 @@ func addVersionCheckCommand(rootCmd *cobra.Command, currentVersion string) {
 		Use:   "version",
 		Short: "Print the version number and check for updates",
 		RunE: func(cmd *cobra.Command, _ []string) error {
-			fmt.Printf("toolkit version: %s\n", currentVersion)
+			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "toolkit version: %s\n", currentVersion)
 			check, _ := cmd.Flags().GetBool("check")
 			if check {
 				latest, err := fetchLatestRelease()
 				if err != nil {
 					return fmt.Errorf("failed to check latest version: %w", err)
 				}
 				if latest == currentVersion {
-					fmt.Println("You are running the latest version.")
+					_, _ = fmt.Fprintln(cmd.OutOrStdout(), "You are running the latest version.")
 				} else {
-					fmt.Printf("A newer version is available: %s\n", latest)
+					_, _ = fmt.Fprintf(cmd.OutOrStdout(), "A newer version is available: %s\n", latest)
 				}
 			}
 			return nil

internal/ui/tui/actions/actions.go

@@ -8,6 +8,8 @@ import (
 	"github.com/jingle2008/toolkit/pkg/models"
 )
 
+var clipboardWriteAll = clipboard.WriteAll
+
 // CopyItemName copies the name or ID of an item to the clipboard.
 func CopyItemName(item any, env *models.Environment, logger logging.Logger) {
 	if item == nil {
@@ -17,11 +19,11 @@ func CopyItemName(item any, env *models.Environment, logger logging.Logger) {
 
 	if dac, ok := item.(*models.DedicatedAICluster); ok {
 		id := dac.GetID(env.Realm, env.Region)
-		if err := clipboard.WriteAll(id); err != nil {
+		if err := clipboardWriteAll(id); err != nil {
 			logger.Errorw("failed to copy id to clipboard", "error", err)
 		}
 	} else if to, ok := item.(models.NamedItem); ok {
-		if err := clipboard.WriteAll(to.GetName()); err != nil {
+		if err := clipboardWriteAll(to.GetName()); err != nil {
 			logger.Errorw("failed to copy name to clipboard", "error", err)
 		}
 	} else {
@@ -38,11 +40,11 @@ func CopyTenantID(item any, env *models.Environment, logger logging.Logger) {
 
 	if dac, ok := item.(*models.DedicatedAICluster); ok {
 		tenantID := dac.GetTenantID(env.Realm)
-		if err := clipboard.WriteAll(tenantID); err != nil {
+		if err := clipboardWriteAll(tenantID); err != nil {
 			logger.Errorw("failed to copy tenantID to clipboard", "error", err)
 		}
 	} else if to, ok := item.(models.TenancyOverride); ok {
-		if err := clipboard.WriteAll(to.GetTenantID()); err != nil {
+		if err := clipboardWriteAll(to.GetTenantID()); err != nil {
 			logger.Errorw("failed to copy tenantID to clipboard", "error", err)
 		}
 	} else {

internal/ui/tui/actions/actions_test.go

@@ -0,0 +1,131 @@
+package actions
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/jingle2008/toolkit/pkg/infra/logging"
+	"github.com/jingle2008/toolkit/pkg/models"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	clipboardValue string
+	clipboardErr   error
+)
+
+// monkey-patch clipboard.WriteAll for tests
+func init() {
+	clipboardWriteAll = func(s string) error {
+		clipboardValue = s
+		return clipboardErr
+	}
+}
+
+// fakeLogger records error messages for assertions
+type fakeLogger struct {
+	msgs []string
+}
+
+func (f *fakeLogger) Errorw(msg string, kv ...any) {
+	f.msgs = append(f.msgs, msg)
+}
+func (f *fakeLogger) Debugw(string, ...any)            {}
+func (f *fakeLogger) Infow(string, ...any)             {}
+func (f *fakeLogger) Sync() error                      { return nil }
+func (f *fakeLogger) WithFields(...any) logging.Logger { return f }
+func (f *fakeLogger) DebugEnabled() bool               { return false }
+
+func TestCopyItemName_Nil(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	CopyItemName(nil, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[0], "no item selected")
+}
+
+type fakeNamed struct{ name string }
+
+func (f fakeNamed) GetName() string { return f.name }
+
+func TestCopyItemName_NamedItem(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardValue = ""
+	clipboardErr = nil
+	CopyItemName(fakeNamed{"foo"}, &models.Environment{}, logger)
+	assert.Equal(t, "foo", clipboardValue)
+}
+
+func TestCopyItemName_DedicatedAICluster(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardValue = ""
+	clipboardErr = nil
+	dac := &models.DedicatedAICluster{}
+	env := &models.Environment{Realm: "realm", Region: "region"}
+	CopyItemName(dac, env, logger)
+}
+
+func TestCopyItemName_Unsupported(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	CopyItemName(123, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[len(logger.msgs)-1], "unsupported item type")
+}
+
+type fakeTenancyOverride struct{ tenantID string }
+
+func (f fakeTenancyOverride) GetTenantID() string { return f.tenantID }
+
+func TestCopyTenantID_TenancyOverride(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardValue = ""
+	clipboardErr = nil
+	to := fakeTenancyOverride{"tid"}
+	CopyTenantID(to, &models.Environment{}, logger)
+	assert.Equal(t, "tid", clipboardValue)
+}
+
+func TestCopyTenantID_DedicatedAICluster(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardValue = ""
+	clipboardErr = nil
+	dac := &models.DedicatedAICluster{}
+	env := &models.Environment{Realm: "realm"}
+	CopyTenantID(dac, env, logger)
+}
+
+func TestCopyTenantID_Nil(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	CopyTenantID(nil, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[0], "no item selected")
+}
+
+func TestCopyTenantID_Unsupported(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	CopyTenantID(123, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[len(logger.msgs)-1], "unsupported item type")
+}
+
+func TestCopyItemName_ClipboardError(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardErr = errors.New("fail")
+	CopyItemName(fakeNamed{"foo"}, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[len(logger.msgs)-1], "failed to copy name")
+	clipboardErr = nil
+}
+
+func TestCopyTenantID_ClipboardError(t *testing.T) {
+	t.Parallel()
+	logger := &fakeLogger{}
+	clipboardErr = errors.New("fail")
+	to := fakeTenancyOverride{"tid"}
+	CopyTenantID(to, &models.Environment{}, logger)
+	assert.Contains(t, logger.msgs[len(logger.msgs)-1], "failed to copy tenantID")
+	clipboardErr = nil
+}

internal/ui/tui/export_csv_test.go

@@ -0,0 +1,119 @@
+package tui
+
+import (
+	"encoding/csv"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/table"
+	"github.com/jingle2008/toolkit/internal/domain"
+	"github.com/jingle2008/toolkit/pkg/models"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestExportTableCSV_Success(t *testing.T) {
+	t.Parallel()
+	tmpDir := t.TempDir()
+	outPath := filepath.Join(tmpDir, "out.csv")
+
+	// Build a minimal Model with headers and table rows
+	headers := []header{
+		{text: "Name"},
+		{text: "Age"},
+	}
+	rows := []table.Row{
+		{"Alice", "30"},
+		{"Bob", "25"},
+	}
+	tbl := table.New()
+	tbl.SetColumns([]table.Column{{Title: "Name"}, {Title: "Age"}})
+	tbl.SetRows(rows)
+
+	m := &Model{
+		headers:     headers,
+		table:       &tbl,
+		category:    domain.Tenant,
+		environment: models.Environment{Region: "us-ashburn-1", Realm: "oc1"},
+		dataset:     &models.Dataset{},
+		loader:      fakeLoader{dataset: &models.Dataset{}},
+		logger:      fakeLogger{},
+	}
+
+	err := m.exportTableCSV(outPath)
+	require.NoError(t, err)
+
+	// Read and check the CSV file
+	// #nosec G304 -- test code, not user input
+	f, err := os.Open(outPath)
+	require.NoError(t, err)
+	defer func() {
+		_ = f.Close()
+	}()
+	r := csv.NewReader(f)
+	records, err := r.ReadAll()
+	require.NoError(t, err)
+	require.Len(t, records, 3)
+	assert.Equal(t, []string{"Name", "Age"}, records[0])
+	assert.Equal(t, []string{"Alice", "30"}, records[1])
+	assert.Equal(t, []string{"Bob", "25"}, records[2])
+}
+
+func TestExportTableCSV_NilModelOrTable(t *testing.T) {
+	t.Parallel()
+	// Nil model
+	var m *Model
+	err := m.exportTableCSV("foo.csv")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "no table data")
+
+	// Nil table
+	m2 := &Model{}
+	err2 := m2.exportTableCSV("foo.csv")
+	require.Error(t, err2)
+	assert.Contains(t, err2.Error(), "no table data")
+}
+
+func TestExportTableCSV_CreateFileError(t *testing.T) {
+	t.Parallel()
+	// Use a path in a non-existent directory
+	m := &Model{
+		headers:     []header{{text: "A"}},
+		table:       &table.Model{},
+		category:    domain.Tenant,
+		environment: models.Environment{Region: "us-ashburn-1", Realm: "oc1"},
+		dataset:     &models.Dataset{},
+		loader:      fakeLoader{dataset: &models.Dataset{}},
+		logger:      fakeLogger{},
+	}
+	badPath := filepath.Join("no_such_dir", "out.csv")
+	err := m.exportTableCSV(badPath)
+	require.Error(t, err)
+}
+
+func TestExportFilename(t *testing.T) {
+	t.Parallel()
+	m := &Model{
+		environment: models.Environment{Region: "iad"},
+		category:    domain.Tenant,
+		loader:      fakeLoader{dataset: &models.Dataset{}},
+		logger:      fakeLogger{},
+	}
+	got := m.exportFilename()
+	assert.Equal(t, "iad-Tenant.csv", got)
+}
+
+func TestExportView_ContainsFilenameAndPrompt(t *testing.T) {
+	t.Parallel()
+	m := &Model{
+		environment: models.Environment{Region: "phx"},
+		category:    domain.Tenant,
+		loader:      fakeLoader{dataset: &models.Dataset{}},
+		logger:      fakeLogger{},
+	}
+	setDefaults(m)
+	view := m.exportView()
+	assert.Contains(t, view, m.exportFilename())
+	assert.Contains(t, view, "Pick an export path:")
+}