refactor: remove internal/logger from platform deploy (#384)

* refactor: remove logger from platform deploy and delete internal/logger package

* refactor: fix package and deploy spinner

* refactor: remove outdate FIXME

* refactor: remove unused result from deployHook func

* refactor: remove DeployResult from Deploy func

* refactor: remove unused return args from deployApp func

* refactor: minor alignments with original source code

* refactor: remove unused sleep time to test packaging

* refactor: replace strPtr and boolPtr with new-new constructor

Author: mwbrooks

cmd/platform/deploy.go

@@ -16,18 +16,15 @@ package platform
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 
 	"github.com/slackapi/slack-cli/cmd/app"
 	"github.com/slackapi/slack-cli/cmd/feedback"
 	"github.com/slackapi/slack-cli/cmd/triggers"
-	"github.com/slackapi/slack-cli/internal/api"
 	"github.com/slackapi/slack-cli/internal/cmdutil"
 	"github.com/slackapi/slack-cli/internal/config"
 	"github.com/slackapi/slack-cli/internal/hooks"
-	"github.com/slackapi/slack-cli/internal/logger"
 	"github.com/slackapi/slack-cli/internal/pkg/platform"
 	"github.com/slackapi/slack-cli/internal/prompts"
 	"github.com/slackapi/slack-cli/internal/shared"
@@ -52,9 +49,6 @@ type deployCmdFlags struct {
 
 var deployFlags deployCmdFlags
 
-var packageSpinner *style.Spinner
-var deploySpinner *style.Spinner
-
 func NewDeployCommand(clients *shared.ClientFactory) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "deploy [flags]",
@@ -68,16 +62,8 @@ func NewDeployCommand(clients *shared.ClientFactory) *cobra.Command {
 			return cmdutil.IsValidProjectDirectory(clients)
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			var event *logger.LogEvent
 			ctx := cmd.Context()
 
-			packageSpinner = style.NewSpinner(cmd.OutOrStdout())
-			deploySpinner = style.NewSpinner(cmd.OutOrStdout())
-			defer func() {
-				packageSpinner.Stop()
-				deploySpinner.Stop()
-			}()
-
 			selection, err := appSelectPromptFunc(ctx, clients, prompts.ShowHostedOnly, prompts.ShowAllApps)
 			if err != nil {
 				return err
@@ -94,22 +80,22 @@ func NewDeployCommand(clients *shared.ClientFactory) *cobra.Command {
 			if installState == types.InstallRequestPending || installState == types.InstallRequestCancelled || installState == types.InstallRequestNotSent {
 				return nil
 			}
+
 			switch {
 			case clients.SDKConfig.Hooks.Deploy.IsAvailable():
-				event, err = deployHook(ctx, clients)
+				err = deployHook(ctx, clients)
 				if err != nil {
 					return err
 				}
 			default:
-				log := newDeployLogger(cmd)
 				showTriggers := triggers.ShowTriggers(clients, deployFlags.hideTriggers)
-				event, err = deployFunc(ctx, clients, showTriggers, log, app)
+				err = deployFunc(ctx, clients, showTriggers, app)
 				if err != nil {
 					return err
 				}
 			}
 
-			err = printDeployHostingCompletion(clients, cmd, event)
+			err = printDeployHostingCompletion(clients, cmd)
 			if err != nil {
 				return err
 			}
@@ -127,25 +113,6 @@ func NewDeployCommand(clients *shared.ClientFactory) *cobra.Command {
 	return cmd
 }
 
-// newDeployLogger creates a logger instance to receive event notifications
-func newDeployLogger(cmd *cobra.Command) *logger.Logger {
-	return logger.New(
-		// OnEvent
-		func(event *logger.LogEvent) {
-			switch event.Name {
-			case "on_app_package":
-				printDeployPackage(cmd, event)
-			case "on_app_package_completion":
-				printDeployPackageCompletion(cmd, event)
-			case "on_app_deploy_hosting":
-				printDeployHosting(cmd, event)
-			default:
-				// Ignore the event
-			}
-		},
-	)
-}
-
 // hasValidDeploymentMethod errors if an app has no known ways to deploy
 func hasValidDeploymentMethod(
 	ctx context.Context,
@@ -188,11 +155,7 @@ func hasValidDeploymentMethod(
 }
 
 // deployHook executes the provided program and streams IO for the process
-func deployHook(ctx context.Context, clients *shared.ClientFactory) (*logger.LogEvent, error) {
-	var log = logger.LogEvent{
-		// FIXME: Include app information
-		Data: logger.LogData{"authSession": "{}"},
-	}
+func deployHook(ctx context.Context, clients *shared.ClientFactory) error {
 	clients.IO.PrintInfo(ctx, false, "\n%s", style.Sectionf(style.TextSection{
 		Emoji:     "mailbox_with_mail",
 		Text:      "App Deploy",
@@ -220,82 +183,16 @@ func deployHook(ctx context.Context, clients *shared.ClientFactory) (*logger.Log
 		IO: clients.IO,
 	}
 	if _, err := shell.Execute(ctx, hookExecOpts); err != nil {
-		return &log, err
+		return err
 	}
 	// Follow successful hook executions with a newline to match section formatting
 	// but break immediately after an error!
 	_, _ = clients.IO.WriteOut().Write([]byte("\n"))
-	return &log, nil
-}
-
-func printDeployPackage(cmd *cobra.Command, event *logger.LogEvent) {
-	cmd.Println()
-	packageSpinner.Update("Packaging app for deployment", "").Start()
-}
-
-func printDeployPackageCompletion(cmd *cobra.Command, event *logger.LogEvent) {
-	packagedSize := event.DataToString("packagedSize")
-	packagedTime := event.DataToString("packagedTime")
-
-	deployPackageSuccessText := style.Sectionf(style.TextSection{
-		Emoji:     "gift",
-		Text:      "App packaged and ready to deploy",
-		Secondary: []string{fmt.Sprintf("%s was packaged in %s", packagedSize, packagedTime)},
-	})
-	packageSpinner.Update(deployPackageSuccessText, "").Stop()
-}
-
-func printDeployHosting(cmd *cobra.Command, event *logger.LogEvent) {
-	deployHostingText := "Deploying to Slack Platform" + style.Secondary(" (this will take a moment)")
-	deploySpinner.Update(deployHostingText, "").Start()
+	return nil
 }
 
-func printDeployHostingCompletion(clients *shared.ClientFactory, cmd *cobra.Command, event *logger.LogEvent) error {
+func printDeployHostingCompletion(clients *shared.ClientFactory, cmd *cobra.Command) error {
 	var ctx = cmd.Context()
-	var authSession api.AuthSession
-
-	appName := event.DataToString("appName")
-	deployTime := event.DataToString("deployTime")
-	err := json.Unmarshal([]byte(event.DataToString("authSession")), &authSession)
-	if err != nil {
-		return err
-	}
-
-	parsedAppInfo := map[string]string{}
-
-	host := clients.API().Host()
-	if appID := event.DataToString("appID"); appID != "" && host != "" {
-		parsedAppInfo["Dashboard"] = fmt.Sprintf("%s/apps/%s", host, appID)
-	}
-
-	if authSession.UserName != nil && authSession.UserID != nil {
-		userInfo := fmt.Sprintf("%s (%s)", *authSession.UserName, *authSession.UserID)
-		parsedAppInfo["App Owner"] = userInfo
-	}
-
-	if authSession.TeamName != nil && authSession.TeamID != nil {
-		workspaceInfo := fmt.Sprintf("%s (%s)", *authSession.TeamName, *authSession.TeamID)
-		if authSession.EnterpriseID != nil {
-			parsedAppInfo["Organization"] = workspaceInfo
-		} else {
-			parsedAppInfo["Workspace"] = workspaceInfo
-		}
-	}
-
-	var finalMessage string
-	if appName != "" && deployTime != "" {
-		finalMessage = fmt.Sprintf("%s deployed in %s", style.Bold(appName), deployTime)
-	} else {
-		finalMessage = "Successfully deployed the app!"
-	}
-
-	successfulDeployText := style.Sectionf(style.TextSection{
-		Emoji:     "rocket",
-		Text:      finalMessage,
-		Secondary: []string{style.Mapf(parsedAppInfo)},
-	})
-
-	deploySpinner.Update(successfulDeployText, "").Stop()
 
 	clients.IO.PrintTrace(ctx, slacktrace.PlatformDeploySuccess)
 

cmd/platform/deploy_test.go

@@ -25,7 +25,6 @@ import (
 	"github.com/slackapi/slack-cli/internal/config"
 	"github.com/slackapi/slack-cli/internal/hooks"
 	"github.com/slackapi/slack-cli/internal/iostreams"
-	"github.com/slackapi/slack-cli/internal/logger"
 	"github.com/slackapi/slack-cli/internal/prompts"
 	"github.com/slackapi/slack-cli/internal/shared"
 	"github.com/slackapi/slack-cli/internal/shared/types"
@@ -44,9 +43,9 @@ type DeployPkgMock struct {
 	mock.Mock
 }
 
-func (m *DeployPkgMock) Deploy(ctx context.Context, clients *shared.ClientFactory, showPrompts bool, log *logger.Logger, app types.App) (*logger.LogEvent, error) {
-	args := m.Called(ctx, clients, showPrompts, log, app)
-	return args.Get(0).(*logger.LogEvent), args.Error(1)
+func (m *DeployPkgMock) Deploy(ctx context.Context, clients *shared.ClientFactory, showPrompts bool, app types.App) error {
+	args := m.Called(ctx, clients, showPrompts, app)
+	return args.Error(0)
 }
 
 // Setup a mock for Install package
@@ -79,9 +78,7 @@ func TestDeployCommand(t *testing.T) {
 
 	deployPkgMock := new(DeployPkgMock)
 	deployFunc = deployPkgMock.Deploy
-	deployPkgMock.On("Deploy", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&logger.LogEvent{
-		Data: logger.LogData{"authSession": "{}"},
-	}, nil)
+	deployPkgMock.On("Deploy", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 	appSelectMock := prompts.NewAppSelectMock()
 	appSelectMock.On("AppSelectPrompt", mock.Anything, mock.Anything, prompts.ShowHostedOnly, prompts.ShowAllApps).Return(prompts.SelectedApp{}, nil)
@@ -106,7 +103,7 @@ func TestDeployCommand(t *testing.T) {
 		assert.Fail(t, "cmd.Execute had unexpected error", err.Error())
 	}
 
-	deployPkgMock.AssertCalled(t, "Deploy", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything)
+	deployPkgMock.AssertCalled(t, "Deploy", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
 }
 
 func TestDeployCommand_HasValidDeploymentMethod(t *testing.T) {
@@ -305,62 +302,23 @@ func TestDeployCommand_DeployHook(t *testing.T) {
 }
 
 func TestDeployCommand_PrintHostingCompletion(t *testing.T) {
-	tests := map[string]struct {
-		event    logger.LogData
-		expected []string
-	}{
-		"information from a workspace deploy is printed": {
-			event: logger.LogData{
-				"appName":     "DeployerApp",
-				"appID":       "A123",
-				"deployTime":  "12.34",
-				"authSession": `{"user": "slackbot", "user_id": "USLACKBOT", "team": "speck", "team_id": "T001"}`,
-			},
-			expected: []string{
-				"DeployerApp deployed in 12.34",
-				"Dashboard:  https://slacker.com/apps/A123",
-				"App Owner:  slackbot (USLACKBOT)",
-				"Workspace:  speck (T001)",
-			},
-		},
-		"information from an enterprise deploy is printed": {
-			event: logger.LogData{
-				"appName":     "Spackulen",
-				"appID":       "A999",
-				"deployTime":  "8.05",
-				"authSession": `{"user": "stub", "user_id": "U111", "team": "spack", "team_id": "E002", "is_enterprise_install": true, "enterprise_id": "E002"}`,
-			},
-			expected: []string{
-				"Spackulen deployed in 8.05",
-				"Dashboard   :  https://slacker.com/apps/A999",
-				"App Owner   :  stub (U111)",
-				"Organization:  spack (E002)",
-			},
-		},
-		"a message is still displayed with missing info": {
-			event: logger.LogData{
-				"authSession": "{}",
-			},
-			expected: []string{
-				"Successfully deployed the app!",
-			},
-		},
-	}
-	for name, tc := range tests {
-		t.Run(name, func(t *testing.T) {
-			clientsMock := shared.NewClientsMock()
-			clientsMock.API.On("Host").Return("https://slacker.com")
-			clientsMock.AddDefaultMocks()
-			clients := shared.NewClientFactory(clientsMock.MockClientFactory())
-			cmd := NewDeployCommand(clients)
-			log := &logger.LogEvent{Data: tc.event}
-			err := printDeployHostingCompletion(clients, cmd, log)
-			assert.NoError(t, err)
-			clientsMock.IO.AssertCalled(t, "PrintTrace", mock.Anything, slacktrace.PlatformDeploySuccess, mock.Anything)
-			spinnerText, _ := deploySpinner.Status()
-			for _, line := range tc.expected {
-				assert.Contains(t, spinnerText, line)
-			}
-		})
-	}
+	ctx := slackcontext.MockContext(t.Context())
+	clientsMock := shared.NewClientsMock()
+	clientsMock.AddDefaultMocks()
+
+	stdoutBuffer := bytes.Buffer{}
+	stdoutLogger := log.Logger{}
+	stdoutLogger.SetOutput(&stdoutBuffer)
+	clientsMock.IO.Stdout = &stdoutLogger
+
+	clients := shared.NewClientFactory(clientsMock.MockClientFactory())
+	cmd := NewDeployCommand(clients)
+	cmd.SetContext(ctx)
+	err := printDeployHostingCompletion(clients, cmd)
+	assert.NoError(t, err)
+	clientsMock.IO.AssertCalled(t, "PrintTrace", mock.Anything, slacktrace.PlatformDeploySuccess, mock.Anything)
+	output := stdoutBuffer.String()
+	assert.Contains(t, output, "Visit Slack to try out your live app!")
+	assert.Contains(t, output, "deploy")
+	assert.Contains(t, output, "activity --tail")
 }