feat: explain required install with no planned resource changes

pkg/action/release_install.go

@@ -498,11 +498,13 @@ func releaseInstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc, re
 		}
 	}
 
-	releaseIsUpToDate, err := release.IsReleaseUpToDate(prevRelease, newRelease)
+	result, err := release.IsReleaseUpToDate(prevRelease, newRelease)
 	if err != nil {
 		return fmt.Errorf("check if release is up to date: %w", err)
 	}
 
+	releaseIsUpToDate := result.UpToDate
+
 	installPlanIsUseless := lo.NoneBy(installPlan.Operations(), func(op *plan.Operation) bool {
 		switch op.Category {
 		case plan.OperationCategoryResource, plan.OperationCategoryTrack:
@@ -910,11 +912,13 @@ func runRollbackPlan(ctx context.Context, releaseName, releaseNamespace string,
 		}
 	}
 
-	releaseIsUpToDate, err := release.IsReleaseUpToDate(failedRelease, newRelease)
+	releaseUpToDateResult, err := release.IsReleaseUpToDate(failedRelease, newRelease)
 	if err != nil {
 		return nil, nonCritErrs, critErrs.Add(fmt.Errorf("check if release is up to date: %w", err))
 	}
 
+	releaseIsUpToDate := releaseUpToDateResult.UpToDate
+
 	planIsUseless := lo.NoneBy(rollbackPlan.Operations(), func(op *plan.Operation) bool {
 		switch op.Category {
 		case plan.OperationCategoryResource, plan.OperationCategoryTrack:

pkg/action/release_plan_install.go

@@ -403,11 +403,13 @@ func releasePlanInstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc
 		}
 	}
 
-	releaseIsUpToDate, err := release.IsReleaseUpToDate(prevRelease, newRelease)
+	result, err := release.IsReleaseUpToDate(prevRelease, newRelease)
 	if err != nil {
 		return fmt.Errorf("check if release is up to date: %w", err)
 	}
 
+	releaseIsUpToDate := result.UpToDate
+
 	installPlanIsUseless := lo.NoneBy(installPlan.Operations(), func(op *plan.Operation) bool {
 		switch op.Category {
 		case plan.OperationCategoryResource, plan.OperationCategoryTrack:
@@ -427,7 +429,7 @@ func releasePlanInstall(ctx context.Context, ctxCancelFn context.CancelCauseFunc
 	if releaseIsUpToDate && installPlanIsUseless {
 		log.Default.Info(ctx, color.Style{color.Bold, color.Green}.Render(fmt.Sprintf("No changes planned for release %q (namespace: %q)", releaseName, releaseNamespace)))
 	} else if installPlanIsUseless || len(changes) == 0 {
-		log.Default.Info(ctx, color.Style{color.Bold, color.Yellow}.Render(fmt.Sprintf("No resource changes planned, but still must install release %q (namespace: %q)", releaseName, releaseNamespace)))
+		log.Default.Info(ctx, color.Style{color.Bold, color.Yellow}.Render(releaseMustInstallMessage(releaseName, releaseNamespace, result.Reason)))
 	}
 
 	if err := logPlannedChanges(ctx, releaseName, releaseNamespace, changes, opts.ResourceDiffOptions); err != nil {
@@ -593,3 +595,12 @@ func logSummaryLine(ctx context.Context, changes []*plan.ResourceChange, changeT
 		log.Default.Info(ctx, "- %s: %d resources", filteredChanges[0].TypeStyle.Render(changeType), len(filteredChanges))
 	}
 }
+
+func releaseMustInstallMessage(releaseName, releaseNamespace string, reason release.ReleaseOutdatedReason) string {
+	msg := fmt.Sprintf("No resource changes planned, but still must install release %q (namespace: %q)", releaseName, releaseNamespace)
+	if reason != release.ReleaseOutdatedReasonNone {
+		msg += " because " + string(reason)
+	}
+
+	return msg
+}

pkg/action/release_plan_install_test.go

@@ -0,0 +1,48 @@
+package action //nolint:testpackage
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/werf/nelm/pkg/release"
+)
+
+func TestReleaseMustInstallMessage(t *testing.T) {
+	tests := []struct {
+		name             string
+		releaseName      string
+		releaseNamespace string
+		reason           release.ReleaseOutdatedReason
+		want             string
+	}{
+		{
+			name:             "no-reason",
+			releaseName:      "myrelease",
+			releaseNamespace: "mynamespace",
+			reason:           release.ReleaseOutdatedReasonNone,
+			want:             `No resource changes planned, but still must install release "myrelease" (namespace: "mynamespace")`,
+		},
+		{
+			name:             "values-changed",
+			releaseName:      "myrelease",
+			releaseNamespace: "mynamespace",
+			reason:           release.ReleaseOutdatedReasonValuesChanged,
+			want:             `No resource changes planned, but still must install release "myrelease" (namespace: "mynamespace") because ` + string(release.ReleaseOutdatedReasonValuesChanged),
+		},
+		{
+			name:             "notes-changed",
+			releaseName:      "myrelease",
+			releaseNamespace: "mynamespace",
+			reason:           release.ReleaseOutdatedReasonNotesChanged,
+			want:             `No resource changes planned, but still must install release "myrelease" (namespace: "mynamespace") because ` + string(release.ReleaseOutdatedReasonNotesChanged),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := releaseMustInstallMessage(tt.releaseName, tt.releaseNamespace, tt.reason)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

pkg/action/release_rollback.go

@@ -337,11 +337,13 @@ func releaseRollback(ctx context.Context, ctxCancelFn context.CancelCauseFunc, r
 		}
 	}
 
-	releaseIsUpToDate, err := release.IsReleaseUpToDate(prevRelease, newRelease)
+	result, err := release.IsReleaseUpToDate(prevRelease, newRelease)
 	if err != nil {
 		return fmt.Errorf("check if release is up to date: %w", err)
 	}
 
+	releaseIsUpToDate := result.UpToDate
+
 	installPlanIsUseless := lo.NoneBy(installPlan.Operations(), func(op *plan.Operation) bool {
 		switch op.Category {
 		case plan.OperationCategoryResource, plan.OperationCategoryTrack:

pkg/release/release.go

@@ -22,59 +22,82 @@ import (
 	"github.com/werf/nelm/pkg/resource/spec"
 )
 
+const (
+	ReleaseOutdatedReasonNone                     ReleaseOutdatedReason = ""
+	ReleaseOutdatedReasonNoPreviousRelease        ReleaseOutdatedReason = "there is no previously deployed release"
+	ReleaseOutdatedReasonReleaseStatusNotDeployed ReleaseOutdatedReason = "the previously deployed release was not successful"
+	ReleaseOutdatedReasonNotesChanged             ReleaseOutdatedReason = "the release notes changed"
+	ReleaseOutdatedReasonValuesChanged            ReleaseOutdatedReason = "the release values changed"
+	ReleaseOutdatedReasonHooksChanged             ReleaseOutdatedReason = "the release hooks changed"
+	ReleaseOutdatedReasonManifestsChanged         ReleaseOutdatedReason = "the release manifests changed"
+)
+
+type ReleaseOutdatedReason string
+
 type ReleaseOptions struct {
 	InfoAnnotations map[string]string
 	Labels          map[string]string
 	Notes           string
 }
 
+type IsReleaseUpToDateResult struct {
+	Reason   ReleaseOutdatedReason
+	UpToDate bool
+}
+
 // Check if the new Release is up-to-date compared to the old Release. It doesn't check any
 // resources of the release in the cluster, just compares Release objects.
-func IsReleaseUpToDate(oldRel, newRel *helmrelease.Release) (bool, error) {
+func IsReleaseUpToDate(oldRel, newRel *helmrelease.Release) (IsReleaseUpToDateResult, error) {
 	if oldRel == nil {
-		return false, nil
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonNoPreviousRelease}, nil
 	}
 
 	cmpOpts := cmp.Options{
 		cmpopts.EquateEmpty(),
 	}
 
-	if oldRel.Info.Status != helmrelease.StatusDeployed ||
-		oldRel.Info.Notes != newRel.Info.Notes ||
-		!cmp.Equal(oldRel.Config, newRel.Config, cmpOpts) {
-		return false, nil
+	if oldRel.Info.Status != helmrelease.StatusDeployed {
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonReleaseStatusNotDeployed}, nil
+	}
+
+	if oldRel.Info.Notes != newRel.Info.Notes {
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonNotesChanged}, nil
+	}
+
+	if !cmp.Equal(oldRel.Config, newRel.Config, cmpOpts) {
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonValuesChanged}, nil
 	}
 
 	oldHookResourcesHash := fnv.New32a()
 	for _, oldHook := range oldRel.Hooks {
 		obj, _, err := scheme.Codecs.UniversalDecoder().Decode([]byte(oldHook.Manifest), nil, &unstructured.Unstructured{})
 		if err != nil {
-			return false, fmt.Errorf("decode old hook: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("decode old hook: %w", err)
 		}
 
 		unstruct := cleanUnstruct(obj.(*unstructured.Unstructured))
 
 		if err := writeUnstructHash(unstruct, oldHookResourcesHash); err != nil {
-			return false, fmt.Errorf("write old hook hash: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("write old hook hash: %w", err)
 		}
 	}
 
 	newHookResourcesHash := fnv.New32a()
 	for _, newHook := range newRel.Hooks {
 		obj, _, err := scheme.Codecs.UniversalDecoder().Decode([]byte(newHook.Manifest), nil, &unstructured.Unstructured{})
 		if err != nil {
-			return false, fmt.Errorf("decode new hook: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("decode new hook: %w", err)
 		}
 
 		unstruct := cleanUnstruct(obj.(*unstructured.Unstructured))
 
 		if err := writeUnstructHash(unstruct, newHookResourcesHash); err != nil {
-			return false, fmt.Errorf("write new hook hash: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("write new hook hash: %w", err)
 		}
 	}
 
 	if oldHookResourcesHash.Sum32() != newHookResourcesHash.Sum32() {
-		return false, nil
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonHooksChanged}, nil
 	}
 
 	oldRelManifests := releaseutil.SplitManifestsToSlice(oldRel.Manifest)
@@ -83,13 +106,13 @@ func IsReleaseUpToDate(oldRel, newRel *helmrelease.Release) (bool, error) {
 	for _, manifest := range oldRelManifests {
 		obj, _, err := scheme.Codecs.UniversalDecoder().Decode([]byte(manifest), nil, &unstructured.Unstructured{})
 		if err != nil {
-			return false, fmt.Errorf("decode old regular resource: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("decode old regular resource: %w", err)
 		}
 
 		unstruct := cleanUnstruct(obj.(*unstructured.Unstructured))
 
 		if err := writeUnstructHash(unstruct, oldRegularResourcesHash); err != nil {
-			return false, fmt.Errorf("write old regular resource hash: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("write old regular resource hash: %w", err)
 		}
 	}
 
@@ -99,21 +122,21 @@ func IsReleaseUpToDate(oldRel, newRel *helmrelease.Release) (bool, error) {
 	for _, manifest := range newRelManifests {
 		obj, _, err := scheme.Codecs.UniversalDecoder().Decode([]byte(manifest), nil, &unstructured.Unstructured{})
 		if err != nil {
-			return false, fmt.Errorf("decode new regular resource: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("decode new regular resource: %w", err)
 		}
 
 		unstruct := cleanUnstruct(obj.(*unstructured.Unstructured))
 
 		if err := writeUnstructHash(unstruct, newRegularResourcesHash); err != nil {
-			return false, fmt.Errorf("write new regular resource hash: %w", err)
+			return IsReleaseUpToDateResult{}, fmt.Errorf("write new regular resource hash: %w", err)
 		}
 	}
 
 	if oldRegularResourcesHash.Sum32() != newRegularResourcesHash.Sum32() {
-		return false, nil
+		return IsReleaseUpToDateResult{Reason: ReleaseOutdatedReasonManifestsChanged}, nil
 	}
 
-	return true, nil
+	return IsReleaseUpToDateResult{UpToDate: true}, nil
 }
 
 // Construct Helm release.