created rit add workspace command

internal/mocks/mocks.go

@@ -354,3 +354,17 @@ func (tm *TemplateManagerMock) Validate() error {
 	args := tm.Called()
 	return args.Error(0)
 }
+
+type WorkspaceMock struct {
+	mock.Mock
+}
+
+func (w *WorkspaceMock) Add(workspace formula.Workspace) error {
+	args := w.Called(workspace)
+	return args.Error(0)
+}
+
+func (w *WorkspaceMock) List() (formula.Workspaces, error) {
+	args := w.Called()
+	return args.Get(0).(formula.Workspaces), args.Error(1)
+}

pkg/api/api.go

@@ -32,6 +32,7 @@ var (
 	CoreCmds = Commands{
 		"root_add":                   {Parent: "root", Usage: "add"},
 		"root_add_repo":              {Parent: "root_add", Usage: "repo"},
+		"root_add_workspace":         {Parent: "root_add", Usage: "workspace"},
 		"root_completion":            {Parent: "root", Usage: "completion"},
 		"root_completion_bash":       {Parent: "root_completion", Usage: "bash"},
 		"root_completion_zsh":        {Parent: "root_completion", Usage: "zsh"},

pkg/cmd/add_workspace.go

@@ -0,0 +1,103 @@
+package cmd
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/ZupIT/ritchie-cli/pkg/formula"
+	"github.com/ZupIT/ritchie-cli/pkg/prompt"
+)
+
+const (
+	workspaceNameFlag            = "name"
+	workspaceNameFlagDescription = "Workspace name"
+	workspacePathFlag            = "path"
+	workspacePathFlagDescription = "Workspace path"
+)
+
+type addWorkspaceCmd struct {
+	workspace formula.WorkspaceAddLister
+	input     prompt.InputText
+}
+
+func NewAddWorkspaceCmd(
+	workspace formula.WorkspaceAddLister,
+	input prompt.InputText,
+) *cobra.Command {
+	a := addWorkspaceCmd{
+		workspace: workspace,
+		input:     input,
+	}
+
+	cmd := &cobra.Command{
+		Use:       "workspace",
+		Short:     "Add new workspace",
+		Example:   "rit add workspace",
+		RunE:      a.runFormula(),
+		ValidArgs: []string{""},
+		Args:      cobra.OnlyValidArgs,
+	}
+
+	flags := cmd.Flags()
+	flags.String(workspaceNameFlag, "", workspaceNameFlagDescription)
+	flags.String(workspacePathFlag, "", workspacePathFlagDescription)
+
+	return cmd
+}
+
+func (a addWorkspaceCmd) runFormula() CommandRunnerFunc {
+	return func(cmd *cobra.Command, args []string) error {
+		if cmd.Flags().NFlag() == 0 {
+			wspace, err := addWorkspaceFromPrompt(a)
+			if err != nil {
+				return err
+			}
+
+			return a.workspace.Add(wspace)
+		}
+
+		wspace, err := addWorkspaceFromFlags(cmd)
+		if err != nil {
+			return err
+		}
+
+		return a.workspace.Add(wspace)
+	}
+}
+
+func addWorkspaceFromFlags(cmd *cobra.Command) (formula.Workspace, error) {
+	workspaceName, _ := cmd.Flags().GetString(workspaceNameFlag)
+	workspacePath, _ := cmd.Flags().GetString(workspacePathFlag)
+
+	if len(workspaceName) == 0 || len(workspacePath) == 0 {
+		return formula.Workspace{}, errors.New("all flags need to be filled")
+	}
+
+	wspace := formula.Workspace{
+		Name: strings.Title(workspaceName),
+		Dir:  workspacePath,
+	}
+
+	return wspace, nil
+}
+
+func addWorkspaceFromPrompt(a addWorkspaceCmd) (formula.Workspace, error) {
+	workspaceName, err := a.input.Text("Enter the name of workspace", true)
+	if err != nil {
+		return formula.Workspace{}, err
+	}
+
+	workspacePath, err := a.input.Text("Enter the path of workspace (e.g.: /home/user/github)", true)
+	if err != nil {
+		return formula.Workspace{}, err
+	}
+
+	wspace := formula.Workspace{
+		Name: strings.Title(workspaceName),
+		Dir:  workspacePath,
+	}
+
+	return wspace, nil
+}

pkg/cmd/add_workspace_test.go

@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/ZupIT/ritchie-cli/internal/mocks"
+	"github.com/ZupIT/ritchie-cli/pkg/formula"
+)
+
+func TestNewAddWorkspaceCmd(t *testing.T) {
+	var tests = []struct {
+		name                  string
+		addWorkspaceWithError error
+		workspaceName         string
+		workspacePath         string
+		argsName              string
+		argsPath              string
+		wantErr               string
+	}{
+		{
+			name:                  "add new workspace by prompt",
+			addWorkspaceWithError: nil,
+			workspaceName:         "Teste",
+			workspacePath:         "/home/user/dir",
+			wantErr:               "",
+		},
+		{
+			name:                  "add new workspace by flags",
+			addWorkspaceWithError: nil,
+			workspaceName:         "Teste",
+			workspacePath:         "/home/user/dir",
+			argsName:              "--name=Teste",
+			argsPath:              "--path=/home/user/dir",
+			wantErr:               "",
+		},
+		{
+			name:                  "error when one flags is no filled",
+			addWorkspaceWithError: nil,
+			workspaceName:         "Teste",
+			workspacePath:         "",
+			argsName:              "--name=Teste",
+			argsPath:              "",
+			wantErr:               "all flags need to be filled",
+		},
+		{
+			name:                  "error when workspace does not exists",
+			addWorkspaceWithError: errors.New("workspace does not exists"),
+			workspaceName:         "Teste",
+			workspacePath:         "/home/user/dir",
+			wantErr:               "workspace does not exists",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			textMock := &mocks.InputTextMock{}
+			textMock.On("Text", "Enter the name of workspace", true, mock.Anything).Return(tt.workspaceName, nil)
+			textMock.On("Text", "Enter the path of workspace (e.g.: /home/user/github)", true, mock.Anything).Return(tt.workspacePath, nil)
+
+			wspace := formula.Workspace{
+				Name: tt.workspaceName,
+				Dir:  tt.workspacePath,
+			}
+
+			workspaceMock := &mocks.WorkspaceMock{}
+			workspaceMock.On("Add", wspace).Return(tt.addWorkspaceWithError)
+
+			addNewWorkspace := NewAddWorkspaceCmd(workspaceMock, textMock)
+			addNewWorkspace.SetArgs([]string{tt.argsName, tt.argsPath})
+
+			err := addNewWorkspace.Execute()
+			if err != nil {
+				assert.Equal(t, err.Error(), tt.wantErr)
+			} else {
+				assert.Empty(t, tt.wantErr)
+			}
+		})
+	}
+}

pkg/commands/builder.go

@@ -237,14 +237,15 @@ func Build() *cobra.Command {
 	autocompletePowerShell := cmd.NewAutocompletePowerShell(autocompleteGen)
 	deleteWorkspaceCmd := cmd.NewDeleteWorkspaceCmd(userHomeDir, formulaWorkspace, dirManager, inputList, inputBool)
 	deleteFormulaCmd := cmd.NewDeleteFormulaCmd(userHomeDir, ritchieHomeDir, formulaWorkspace, dirManager, inputBool, inputText, inputList, treeGen, fileManager)
+	addWorkspaceCmd := cmd.NewAddWorkspaceCmd(formulaWorkspace, inputText)
 
 	createFormulaCmd := cmd.NewCreateFormulaCmd(userHomeDir, createBuilder, tplManager, formulaWorkspace, inputText, inputTextValidator, inputList, tutorialFinder, treeChecker)
 	buildFormulaCmd := cmd.NewBuildFormulaCmd()
 	showFormulaRunnerCmd := cmd.NewShowFormulaRunnerCmd(configManager)
 	setFormulaRunnerCmd := cmd.NewSetFormulaRunnerCmd(configManager, inputList)
 
 	autocompleteCmd.AddCommand(autocompleteZsh, autocompleteBash, autocompleteFish, autocompletePowerShell)
-	addCmd.AddCommand(addRepoCmd)
+	addCmd.AddCommand(addRepoCmd, addWorkspaceCmd)
 	updateCmd.AddCommand(updateRepoCmd)
 	createCmd.AddCommand(createFormulaCmd)
 	deleteCmd.AddCommand(deleteEnvCmd, deleteRepoCmd, deleteFormulaCmd, deleteWorkspaceCmd, deleteCredentialCmd)