tests

Makefile

@@ -75,3 +75,12 @@ goreleaser:
 
 tags:
 	gotags -R *.go > $@
+
+generate: | install_tools
+	go generate ./...
+.PHONY:generate
+
+install_tools:
+	go install go.uber.org/mock/mockgen@latest
+	go install golang.org/x/tools/cmd/stringer@latest
+.PHONY: install_tools

auth/auth_ui/auth_ui.go

@@ -1,6 +1,8 @@
 package auth_ui
 
 import (
+	"errors"
+	"fmt"
 	"net/url"
 	"strings"
 )
@@ -20,9 +22,11 @@ const (
 	LCancel
 )
 
+var ErrInvalidDomain = errors.New("invalid domain")
+
 // Sanitize takes a workspace name or URL and returns the workspace name.
 func Sanitize(workspace string) (string, error) {
-	if !strings.Contains(workspace, ".slack.com") {
+	if !strings.Contains(workspace, ".slack.com") && !strings.Contains(workspace, ".") {
 		return workspace, nil
 	}
 	if strings.HasPrefix(workspace, "https://") {
@@ -33,6 +37,12 @@ func Sanitize(workspace string) (string, error) {
 		workspace = uri.Host
 	}
 	// parse
-	parts := strings.Split(workspace, ".")
-	return parts[0], nil
+	name, domain, found := strings.Cut(workspace, ".")
+	if !found {
+		return "", errors.New("workspace name is empty")
+	}
+	if strings.TrimRight(domain, "/") != "slack.com" {
+		return "", fmt.Errorf("%s: %w", domain, ErrInvalidDomain)
+	}
+	return name, nil
 }

auth/auth_ui/auth_ui_test.go

@@ -17,6 +17,7 @@ func TestSanitize(t *testing.T) {
 		{"url no slash", args{"https://blahblah.slack.com"}, "blahblah", false},
 		{"url no schema slash", args{"blahblah.slack.com/"}, "blahblah", false},
 		{"url no schema no slash", args{"blahblah.slack.com"}, "blahblah", false},
+		{"not a slack domain", args{"blahblah.example.com"}, "", true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

cmd/slackdump/internal/workspace/workspaceui/api.go

@@ -2,11 +2,13 @@ package workspaceui
 
 import (
 	"context"
+	"errors"
 
 	"github.com/rusq/slackdump/v3/auth"
 	"github.com/rusq/slackdump/v3/auth/auth_ui"
 )
 
+//go:generate mockgen -package workspaceui -destination=test_mock_manager.go -source api.go manager
 type manager interface {
 	SaveProvider(workspace string, p auth.Provider) error
 	Select(workspace string) error
@@ -24,6 +26,9 @@ func createAndSelect(ctx context.Context, m manager, prov auth.Provider) (string
 	if err != nil {
 		return "", err
 	}
+	if wsp == "" {
+		return "", errors.New("workspace name is empty")
+	}
 	if err := m.SaveProvider(wsp, prov); err != nil {
 		return "", err
 	}

cmd/slackdump/internal/workspace/workspaceui/api_test.go

@@ -0,0 +1,117 @@
+package workspaceui
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rusq/slack"
+	"github.com/rusq/slackdump/v3/internal/fixtures"
+	"github.com/rusq/slackdump/v3/internal/mocks/mock_auth"
+	"github.com/stretchr/testify/assert"
+	gomock "go.uber.org/mock/gomock"
+)
+
+func Test_createAndSelect(t *testing.T) {
+	type args struct {
+		ctx context.Context
+		// m    manager
+		// prov auth.Provider
+	}
+	tests := []struct {
+		name     string
+		args     args
+		expectFn func(mp *mock_auth.MockProvider, mm *Mockmanager)
+		want     string
+		wantErr  bool
+	}{
+		{
+			name: "provider test fails",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(nil, assert.AnError)
+			},
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "save provider fails",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(fixtures.LoadPtr[slack.AuthTestResponse](string(fixtures.TestAuthTestInfo)), nil)
+				mm.EXPECT().SaveProvider(gomock.Any(), gomock.Any()).Return(assert.AnError)
+			},
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "select fails",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(fixtures.LoadPtr[slack.AuthTestResponse](string(fixtures.TestAuthTestInfo)), nil)
+				mm.EXPECT().SaveProvider(gomock.Any(), gomock.Any()).Return(nil)
+				mm.EXPECT().Select(gomock.Any()).Return(assert.AnError)
+			},
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "success",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(fixtures.LoadPtr[slack.AuthTestResponse](string(fixtures.TestAuthTestInfo)), nil)
+				mm.EXPECT().SaveProvider(gomock.Any(), gomock.Any()).Return(nil)
+				mm.EXPECT().Select(gomock.Any()).Return(nil)
+			},
+			want:    "test",
+			wantErr: false,
+		},
+		{
+			name: "url empty fails",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(&slack.AuthTestResponse{URL: ""}, nil)
+			},
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "url sanitize fails",
+			args: args{
+				ctx: context.Background(),
+			},
+			expectFn: func(mp *mock_auth.MockProvider, mm *Mockmanager) {
+				mp.EXPECT().Test(gomock.Any()).Return(&slack.AuthTestResponse{URL: "ftp://lol.example.com"}, nil)
+			},
+			want:    "",
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			mp := mock_auth.NewMockProvider(ctrl)
+			mm := NewMockmanager(ctrl)
+			if tt.expectFn != nil {
+				tt.expectFn(mp, mm)
+			}
+			got, err := createAndSelect(tt.args.ctx, mm, mp)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("createAndSelect() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("createAndSelect() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

cmd/slackdump/internal/workspace/workspaceui/filesecrets.go

@@ -32,6 +32,7 @@ func fileWithSecrets(ctx context.Context, mgr manager) error {
 			return nil
 		}
 	}
+
 	tok, cookie, err := parseSecretsTxt(filename)
 	if err != nil {
 		return err
@@ -54,6 +55,12 @@ func validateSecrets(filename string) error {
 }
 
 func parseSecretsTxt(filename string) (string, string, error) {
+	const (
+		tokenKey  = "SLACK_TOKEN"
+		cookieKey = "SLACK_COOKIE"
+
+		clientTokenPrefix = "xoxc-"
+	)
 	f, err := os.Open(filename)
 	if err != nil {
 		return "", "", err
@@ -63,19 +70,19 @@ func parseSecretsTxt(filename string) (string, string, error) {
 	if err != nil {
 		return "", "", errors.New("not a secrets file")
 	}
-	token, ok := secrets["SLACK_TOKEN"]
+	token, ok := secrets[tokenKey]
 	if !ok {
-		return "", "", errors.New("no SLACK_TOKEN found")
+		return "", "", errors.New("no SLACK_TOKEN found in the file")
 	}
 	if err := structures.ValidateToken(token); err != nil {
 		return "", "", err
 	}
-	if !strings.HasPrefix(token, "xoxc-") {
+	if !strings.HasPrefix(token, clientTokenPrefix) {
 		return token, "", nil
 	}
-	cook, ok := secrets["SLACK_COOKIE"]
+	cook, ok := secrets[cookieKey]
 	if !ok {
-		return "", "", errors.New("no SLACK_COOKIE found")
+		return "", "", errors.New("no SLACK_COOKIE found in the file")
 	}
 	if !strings.HasPrefix(cook, "xoxd-") {
 		return "", "", errors.New("invalid cookie")