Add service level tests

pkg/api/service.go

@@ -88,17 +88,19 @@ func (s Service) Upgrade(ctx context.Context, cfg ReleaseConfig, values chartVal
 	if err != nil {
 		return nil, fmt.Errorf("error merging values: %v", err)
 	}
+
 	if s.upgrader.GetInstall() {
 		if _, err := s.history.Run(cfg.Name); err == driver.ErrReleaseNotFound {
 			fmt.Printf("Release %q does not exist. Installing it now.\n", cfg.Name)
 			return s.installChart(cfg, chart, vals)
 		}
 	}
+
 	return s.upgradeRelease(cfg, chart, vals)
 }
 
 func (s Service) loadChart(chartName string) (*chart.Chart, error) {
-	logger.Debugf("[Install] chart name: %s", chartName)
+	logger.Debugf("[install/upgrade] chart name: %s", chartName)
 	cp, err := s.chartloader.LocateChart(chartName, s.settings)
 	if err != nil {
 		return nil, fmt.Errorf("error in locating chart: %v", err)
@@ -127,7 +129,7 @@ func (s Service) upgradeRelease(ucfg ReleaseConfig, ch *chart.Chart, vals chartV
 	s.upgrader.SetConfig(ucfg)
 	release, err := s.upgrader.Run(ucfg.Name, ch, vals)
 	if err != nil {
-		return nil, fmt.Errorf("error in installing chart: %v", err)
+		return nil, fmt.Errorf("error in upgrading chart: %v", err)
 	}
 	result := new(ReleaseResult)
 	if release.Info != nil {

pkg/api/service_test.go

@@ -13,6 +13,7 @@ import (
 	"helm.sh/helm/v3/pkg/chart"
 	"helm.sh/helm/v3/pkg/cli"
 	"helm.sh/helm/v3/pkg/release"
+	"helm.sh/helm/v3/pkg/storage/driver"
 )
 
 type ServiceTestSuite struct {
@@ -76,7 +77,7 @@ func (s *ServiceTestSuite) TestInstallShouldReturnErrorOnLocalChartReference() {
 	s.installer.AssertNotCalled(t, "Run")
 }
 
-func (s *ServiceTestSuite) TestInstallShouldReturnErrorOnFailedIntallRun() {
+func (s *ServiceTestSuite) TestInstallShouldReturnErrorOnFailedInstallRun() {
 	chartName := "stable/valid-chart"
 	cfg := ReleaseConfig{
 		Name:      "some-component",
@@ -121,6 +122,102 @@ func (s *ServiceTestSuite) TestInstallShouldReturnResultOnSuccess() {
 	s.installer.AssertExpectations(t)
 }
 
+func (s *ServiceTestSuite) TestUpgradeInstallTrueShouldInstallChart() {
+	chartName := "stable/valid-chart"
+	cfg := ReleaseConfig{
+		Name:      "some-component",
+		Namespace: "hermes",
+		ChartName: chartName,
+	}
+	var vals map[string]interface{}
+	s.chartloader.On("LocateChart", chartName, s.settings).Return("testdata/albatross", nil)
+	s.upgrader.On("GetInstall").Return(true)
+	s.history.On("Run", "some-component").Return([]*release.Release{}, driver.ErrReleaseNotFound)
+
+	s.installer.On("SetConfig", cfg)
+	release := &release.Release{Name: "some-comp-release", Info: &release.Info{Status: release.StatusDeployed}}
+	s.installer.On("Run", mock.AnythingOfType("*chart.Chart"), vals).Return(release, nil)
+	res, err := s.svc.Upgrade(s.ctx, cfg, vals)
+
+	t := s.T()
+	assert.NoError(t, err)
+	require.NotNil(t, res)
+	assert.Equal(t, res.status, "deployed")
+	s.chartloader.AssertExpectations(t)
+	s.installer.AssertExpectations(t)
+}
+
+func (s *ServiceTestSuite) TestUpgradeInstallFalseShouldNotInstallChart() {
+	chartName := "stable/valid-chart"
+	cfg := ReleaseConfig{
+		Name:      "some-component",
+		Namespace: "hermes",
+		ChartName: chartName,
+	}
+	var vals map[string]interface{}
+	s.chartloader.On("LocateChart", chartName, s.settings).Return("testdata/albatross", nil)
+	s.upgrader.On("GetInstall").Return(false)
+
+	s.upgrader.On("SetConfig", cfg)
+	release := &release.Release{Name: "some-comp-release", Info: &release.Info{Status: release.StatusDeployed}}
+	s.upgrader.On("Run", "some-component", mock.AnythingOfType("*chart.Chart"), vals).Return(release, nil)
+	res, err := s.svc.Upgrade(s.ctx, cfg, vals)
+
+	t := s.T()
+	assert.NoError(t, err)
+	require.NotNil(t, res)
+	s.installer.AssertNotCalled(t, "Run")
+	s.history.AssertNotCalled(t, "Run")
+	assert.Equal(t, res.status, "deployed")
+	s.chartloader.AssertExpectations(t)
+	s.installer.AssertExpectations(t)
+}
+
+func (s *ServiceTestSuite) TestUpgradeShouldReturnErrorOnFailedUpgradeRun() {
+	chartName := "stable/valid-chart"
+	cfg := ReleaseConfig{
+		Name:      "some-component",
+		Namespace: "hermes",
+		ChartName: chartName,
+	}
+	var vals map[string]interface{}
+	s.chartloader.On("LocateChart", chartName, s.settings).Return("testdata/albatross", nil)
+	s.upgrader.On("GetInstall").Return(false)
+	s.upgrader.On("SetConfig", cfg)
+	release := &release.Release{Name: "some-comp-release", Info: &release.Info{Status: release.StatusDeployed}}
+	s.upgrader.On("Run", "some-component", mock.AnythingOfType("*chart.Chart"), vals).Return(release, errors.New("cluster issue"))
+
+	res, err := s.svc.Upgrade(s.ctx, cfg, vals)
+	t := s.T()
+	assert.Nil(t, res)
+	assert.EqualError(t, err, "error in upgrading chart: cluster issue")
+	s.chartloader.AssertExpectations(t)
+	s.installer.AssertExpectations(t)
+}
+
+func (s *ServiceTestSuite) TestUpgradeShouldReturnResultOnSuccess() {
+	chartName := "stable/valid-chart"
+	cfg := ReleaseConfig{
+		Name:      "some-component",
+		Namespace: "hermes",
+		ChartName: chartName,
+	}
+	var vals map[string]interface{}
+	s.chartloader.On("LocateChart", chartName, s.settings).Return("testdata/albatross", nil)
+	s.upgrader.On("GetInstall").Return(false)
+	s.upgrader.On("SetConfig", cfg)
+	release := &release.Release{Name: "some-comp-release", Info: &release.Info{Status: release.StatusDeployed}}
+	s.upgrader.On("Run", "some-component", mock.AnythingOfType("*chart.Chart"), vals).Return(release, nil)
+
+	res, err := s.svc.Upgrade(s.ctx, cfg, vals)
+	t := s.T()
+	assert.NoError(t, err)
+	require.NotNil(t, res)
+	assert.Equal(t, res.status, "deployed")
+	s.chartloader.AssertExpectations(t)
+	s.upgrader.AssertExpectations(t)
+}
+
 func TestServiceSuite(t *testing.T) {
 	suite.Run(t, new(ServiceTestSuite))
 }

pkg/api/upgrade.go

@@ -35,12 +35,12 @@ func Upgrade(svc Service) http.Handler {
 		cfg := ReleaseConfig{ChartName: req.Chart, Name: req.Name, Namespace: req.Namespace}
 		res, err := svc.Upgrade(r.Context(), cfg, req.Values)
 		if err != nil {
-			respondError(w, "error while installing chart: %v", err)
+			respondError(w, "error while upgrading chart: %v", err)
 			return
 		}
 		response.Status = res.status
 		if err := json.NewEncoder(w).Encode(&response); err != nil {
-			logger.Errorf("[Install] error writing response %v", err)
+			logger.Errorf("[Upgrade] error writing response %v", err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}