Fix- Print error messages in pre builder

internal/mocks/formula.go

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 ZUP IT SERVICOS EM TECNOLOGIA E INOVACAO SA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mocks
+
+import (
+	"github.com/ZupIT/ritchie-cli/pkg/formula"
+	"github.com/stretchr/testify/mock"
+)
+
+type BuilderMock struct {
+	mock.Mock
+}
+
+func (b *BuilderMock) Build(info formula.BuildInfo) error {
+	args := b.Called(info)
+	return args.Error(0)
+}
+
+func (b *BuilderMock) HasBuilt() bool {
+	args := b.Called()
+	return args.Bool(0)
+}

internal/mocks/runner.go

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 ZUP IT SERVICOS EM TECNOLOGIA E INOVACAO SA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mocks
+
+import "github.com/stretchr/testify/mock"
+
+type PreRunBuilder struct {
+	mock.Mock
+}
+
+func (prb *PreRunBuilder) Build(relativePath string) error {
+	args := prb.Called(relativePath)
+	return args.Error(0)
+}

internal/mocks/workspace.go

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2020 ZUP IT SERVICOS EM TECNOLOGIA E INOVACAO SA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mocks
+
+import (
+	"github.com/ZupIT/ritchie-cli/pkg/formula"
+	"github.com/stretchr/testify/mock"
+)
+
+type WorkspaceListHasherMock struct {
+	mock.Mock
+}
+
+func (w *WorkspaceListHasherMock) List() (formula.Workspaces, error) {
+	args := w.Called()
+	return args.Get(0).(formula.Workspaces), args.Error(1)
+}
+
+func (w *WorkspaceListHasherMock) CurrentHash(formulaPath string) (string, error) {
+	args := w.Called(formulaPath)
+	return args.String(0), args.Error(1)
+}
+
+func (w *WorkspaceListHasherMock) PreviousHash(formulaPath string) (string, error) {
+	args := w.Called(formulaPath)
+	return args.String(0), args.Error(1)
+}
+
+func (w *WorkspaceListHasherMock) UpdateHash(formulaPath string, hash string) error {
+	args := w.Called(formulaPath, hash)
+	return args.Error(0)
+}

pkg/formula/repo.go

@@ -16,7 +16,11 @@
 
 package formula
 
-import "github.com/ZupIT/ritchie-cli/pkg/git"
+import (
+	"sort"
+
+	"github.com/ZupIT/ritchie-cli/pkg/git"
+)
 
 const RepoCommonsName = RepoName("commons")
 
@@ -88,6 +92,8 @@ func (re RepoProviders) List() []string {
 		providers = append(providers, provider.String())
 	}
 
+	sort.Strings(providers)
+
 	return providers
 }
 

pkg/formula/runner.go

@@ -35,7 +35,7 @@ type Executor interface {
 }
 
 type PreRunBuilder interface {
-	Build(string)
+	Build(string) error
 }
 
 type PreRunner interface {

pkg/formula/runner/executor.go

@@ -52,7 +52,9 @@ func (ex ExecutorManager) Execute(exe formula.ExecuteData) error {
 	}
 
 	if strings.HasPrefix(exe.Def.RepoName, "local-") {
-		ex.preRunBuilder.Build(exe.Def.Path)
+		if err := ex.preRunBuilder.Build(exe.Def.Path); err != nil {
+			return err
+		}
 	}
 
 	if err := runner.Run(exe.Def, exe.InType, exe.Verbose, exe.Flags); err != nil {

pkg/formula/runner/executor_test.go

@@ -21,16 +21,20 @@ import (
 	"testing"
 
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 
+	"github.com/ZupIT/ritchie-cli/internal/mocks"
 	"github.com/ZupIT/ritchie-cli/pkg/api"
 	"github.com/ZupIT/ritchie-cli/pkg/formula"
 )
 
 func TestExecute(t *testing.T) {
 	type in struct {
-		runners formula.Runners
-		config  formula.ConfigRunner
-		exe     formula.ExecuteData
+		runners            formula.Runners
+		config             formula.ConfigRunner
+		exe                formula.ExecuteData
+		preRunBuilderError error
 	}
 
 	tests := []struct {
@@ -89,6 +93,23 @@ func TestExecute(t *testing.T) {
 			},
 			want: nil,
 		},
+		{
+			name: "execute repo local success",
+			in: in{
+				runners: formula.Runners{
+					formula.LocalRun:  localRunnerMock{},
+					formula.DockerRun: dockerRunnerMock{},
+				},
+				config: configRunnerMock{runType: formula.LocalRun},
+				exe: formula.ExecuteData{
+					Def:     formula.Definition{RepoName: "local-user"},
+					InType:  0,
+					RunType: formula.DefaultRun,
+					Verbose: false,
+				},
+			},
+			want: nil,
+		},
 		{
 			name: "find default runner error",
 			in: in{
@@ -123,16 +144,35 @@ func TestExecute(t *testing.T) {
 			},
 			want: errors.New("error to run formula"),
 		},
+		{
+			name: "run pre run builder error",
+			in: in{
+				runners: formula.Runners{
+					formula.LocalRun:  localRunnerMock{},
+					formula.DockerRun: dockerRunnerMock{},
+				},
+				config: configRunnerMock{runType: formula.DockerRun},
+				exe: formula.ExecuteData{
+					Def:     formula.Definition{RepoName: "local-teste"},
+					InType:  0,
+					RunType: formula.DefaultRun,
+					Verbose: false,
+				},
+				preRunBuilderError: errors.New("error to pre run builder formula"),
+			},
+			want: errors.New("error to pre run builder formula"),
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			executorManager := NewExecutor(tt.in.runners, preRunBuilderMock{}, tt.in.config)
+			preRunBuilder := new(mocks.PreRunBuilder)
+			preRunBuilder.On("Build", mock.Anything).Return(tt.in.preRunBuilderError)
+
+			executorManager := NewExecutor(tt.in.runners, preRunBuilder, tt.in.config)
 			got := executorManager.Execute(tt.in.exe)
 
-			if (tt.want != nil && got == nil) || got != nil && got.Error() != tt.want.Error() {
-				t.Errorf("Execute(%s) got %v, want %v", tt.name, got, tt.want)
-			}
+			assert.Equal(t, tt.want, got)
 		})
 	}
 }
@@ -166,7 +206,3 @@ func (c configRunnerMock) Create(runType formula.RunnerType) error {
 func (c configRunnerMock) Find() (formula.RunnerType, error) {
 	return c.runType, c.findErr
 }
-
-type preRunBuilderMock struct{}
-
-func (bm preRunBuilderMock) Build(string) {}

pkg/formula/runner/pre_run_builder.go

@@ -17,16 +17,16 @@
 package runner
 
 import (
+	"errors"
 	"fmt"
 	"path/filepath"
 
 	"github.com/ZupIT/ritchie-cli/pkg/formula"
-	"github.com/ZupIT/ritchie-cli/pkg/prompt"
 )
 
 const (
-	messageChangeError = "Failed to detect formula changes, executing the last build"
-	messageBuildError  = "Failed to build formula"
+	messageChangeError = "Failed to detect formula changes, executing the last build: %s"
+	messageBuildError  = "Failed to build formula: %s"
 )
 
 type PreRunBuilderManager struct {
@@ -44,22 +44,24 @@ func NewPreRunBuilder(
 	}
 }
 
-func (b PreRunBuilderManager) Build(relativePath string) {
+func (b PreRunBuilderManager) Build(relativePath string) error {
 	workspace, err := b.modifiedWorkspace(relativePath)
 	if err != nil {
-		fmt.Println(prompt.Yellow(messageChangeError))
-		return
+		msg := fmt.Sprintf(messageChangeError, err.Error())
+		return errors.New(msg)
 	}
 
 	// No modifications on any workspace, skip
 	if workspace == nil {
-		return
+		return nil
 	}
 
 	if err = b.buildOnWorkspace(*workspace, relativePath); err != nil {
-		fmt.Println(prompt.Red(messageBuildError))
-		return
+		msg := fmt.Sprintf(messageBuildError, err.Error())
+		return errors.New(msg)
 	}
+
+	return nil
 }
 
 func (b PreRunBuilderManager) modifiedWorkspace(relativePath string) (*formula.Workspace, error) {