[DDO-3469] Thelma refactoring: remove state.Destinations() interface

Makefile

@@ -220,7 +220,6 @@ mocks: ## Generate testify mocks with Mockery
 	mockery --dir ./internal/thelma/state/api/terra --name ClusterRelease --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename cluster_release.go
 	mockery --dir ./internal/thelma/state/api/terra --name Clusters --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename clusters.go
 	mockery --dir ./internal/thelma/state/api/terra --name Destination --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename destination.go
-	mockery --dir ./internal/thelma/state/api/terra --name Destinations --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename destinations.go
 	mockery --dir ./internal/thelma/state/api/terra --name Environment --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename environment.go
 	mockery --dir ./internal/thelma/state/api/terra --name Environments --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename environments.go
 	mockery --dir ./internal/thelma/state/api/terra --name Release --output=./internal/thelma/state/api/terra/mocks --outpkg mocks --filename release.go

internal/thelma/cli/selector/enum_flags.go

@@ -151,15 +151,23 @@ func newDestinationBasesFlag() *enumFlag {
 		usageMessage:  `Run for a specific environment or cluster base (eg. \"live\", \"bee\")`,
 
 		validValues: func(state terra.State) (set.StringSet, error) {
-			destinations, err := state.Destinations().All()
+			envs, err := state.Environments().All()
+			if err != nil {
+				return nil, err
+			}
+			clusters, err := state.Clusters().All()
 			if err != nil {
 				return nil, err
 			}
 
 			s := set.NewStringSet()
-			for _, d := range destinations {
+			for _, d := range envs {
 				s.Add(d.Base())
 			}
+			for _, d := range clusters {
+				s.Add(d.Base())
+			}
+
 			return s, nil
 		},
 

internal/thelma/state/api/terra/state.go

@@ -4,8 +4,6 @@ package terra
 
 // State is an interface for querying the state of Terra infrastructure.
 type State interface {
-	// Destinations is an interface for querying terra.Destination instances
-	Destinations() Destinations
 	// Environments is an interface for querying terra.Environment instances
 	Environments() Environments
 	// Clusters is an interface for querying terra.Cluster instances

internal/thelma/state/providers/sherlock/releases.go

@@ -15,13 +15,8 @@ func newReleasesView(s *state) terra.Releases {
 func (r *releases) All() ([]terra.Release, error) {
 	var result []terra.Release
 
-	allDestinations, err := r.state.Destinations().All()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, destination := range allDestinations {
-		result = append(result, destination.Releases()...)
+	for _, r := range r.state.releases {
+		result = append(result, r)
 	}
 
 	return result, nil

internal/thelma/state/providers/sherlock/state.go

@@ -10,10 +10,7 @@ type state struct {
 	sherlock     sherlock.Client
 	environments map[string]*environment
 	clusters     map[string]*cluster
-}
-
-func (s *state) Destinations() terra.Destinations {
-	return newDestinationsView(s)
+	releases     map[string]*release
 }
 
 func (s *state) Environments() terra.Environments {

internal/thelma/state/providers/sherlock/state_loader.go

@@ -120,6 +120,7 @@ retry:
 			}
 		}
 
+		_releases := make(map[string]*release)
 		for _, stateRelease := range stateReleases {
 			if _, knownCluster := _clusters[stateRelease.Cluster]; stateRelease.Cluster != "" && !knownCluster {
 				log.Warn().Msgf("chart release '%s' has cluster '%s' that we do not have: race condition detected, retrying...",
@@ -131,52 +132,50 @@ retry:
 					stateRelease.Name, stateRelease.Environment)
 				continue retry
 			}
+
+			_release := &release{
+				name:         stateRelease.Name,
+				enabled:      true,
+				chartVersion: stateRelease.ChartVersionExact,
+				chartName:    stateRelease.Chart,
+				repo:         *stateRelease.ChartInfo.ChartRepo,
+				namespace:    stateRelease.Namespace,
+				cluster:      _clusters[stateRelease.Cluster],
+				helmfileRef:  *stateRelease.HelmfileRef,
+				appVersion:   stateRelease.AppVersionExact,
+				subdomain:    stateRelease.Subdomain,
+				protocol:     stateRelease.Protocol,
+				port:         int(stateRelease.Port),
+			}
+
 			switch stateRelease.DestinationType {
 			case "cluster":
-				_clusters[stateRelease.Cluster].releases[stateRelease.Name] = &release{
-					name:         stateRelease.Name,
-					enabled:      true,
-					releaseType:  terra.ClusterReleaseType,
-					chartVersion: stateRelease.ChartVersionExact,
-					chartName:    stateRelease.Chart,
-					repo:         *stateRelease.ChartInfo.ChartRepo,
-					namespace:    stateRelease.Namespace,
-					cluster:      _clusters[stateRelease.Cluster],
-					destination:  _clusters[stateRelease.Cluster],
-					helmfileRef:  *stateRelease.HelmfileRef,
-					appVersion:   stateRelease.AppVersionExact,
-				}
+				_release.releaseType = terra.ClusterReleaseType
+				_release.destination = _clusters[stateRelease.Cluster]
+				_clusters[stateRelease.Cluster].releases[stateRelease.Name] = _release
+
 			case "environment":
 				var helmfileOverlays []string
 				if e, present := _environments[stateRelease.Environment]; present && e.offline {
 					helmfileOverlays = []string{"offline"}
 				}
-				_environments[stateRelease.Environment].releases[stateRelease.Name] = &release{
-					name:             stateRelease.Name,
-					enabled:          true,
-					releaseType:      terra.AppReleaseType,
-					chartVersion:     stateRelease.ChartVersionExact,
-					chartName:        stateRelease.Chart,
-					repo:             *stateRelease.ChartInfo.ChartRepo,
-					namespace:        stateRelease.Namespace,
-					cluster:          _clusters[stateRelease.Cluster],
-					destination:      _environments[stateRelease.Environment],
-					helmfileRef:      *stateRelease.HelmfileRef,
-					helmfileOverlays: helmfileOverlays,
-					appVersion:       stateRelease.AppVersionExact,
-					subdomain:        stateRelease.Subdomain,
-					protocol:         stateRelease.Protocol,
-					port:             int(stateRelease.Port),
-				}
+				_release.releaseType = terra.AppReleaseType
+				_release.destination = _environments[stateRelease.Environment]
+				_release.helmfileOverlays = helmfileOverlays
+				_environments[stateRelease.Environment].releases[stateRelease.Name] = _release
+
 			default:
 				return nil, errors.Errorf("unexpected destination type '%s' for release '%s'", stateRelease.DestinationType, stateRelease.Name)
 			}
+
+			_releases[stateRelease.Name] = _release
 		}
 
 		_state := &state{
 			sherlock:     s.sherlock,
 			environments: _environments,
 			clusters:     _clusters,
+			releases:     _releases,
 		}
 		s.cached = _state
 		return _state, nil

internal/thelma/state/testing/statefixtures/builder.go

@@ -16,7 +16,6 @@ type builder struct {
 	clusterReleaseSet map[string]*statemocks.ClusterRelease
 	clusters          *statemocks.Clusters
 	environments      *StubEnvironments
-	destinations      *StubDestinations
 	releases          *StubReleases
 	state             *statemocks.State
 	stateLoader       *statemocks.StateLoader
@@ -31,7 +30,6 @@ func newBuilder(data *FixtureData) *builder {
 		clusterReleaseSet: make(map[string]*statemocks.ClusterRelease),
 		clusters:          new(statemocks.Clusters),
 		environments:      &StubEnvironments{Environments: new(statemocks.Environments)},
-		destinations:      &StubDestinations{Destinations: new(statemocks.Destinations)},
 		releases:          &StubReleases{Releases: new(statemocks.Releases)},
 		state:             new(statemocks.State),
 		stateLoader:       new(statemocks.StateLoader),
@@ -50,15 +48,13 @@ func (b *builder) buildMocks() *Mocks {
 	b.setClustersMocks()
 	b.setEnvironmentsMocks()
 	b.setReleasesMocks()
-	b.setDestinationsMocks()
 
 	// set up root objects
 	b.setStateMocks()
 	b.setStateLoaderMocks()
 
 	return &Mocks{
 		Clusters:     b.clusters,
-		Destinations: b.destinations,
 		Environments: b.environments,
 		Releases:     b.releases,
 		State:        b.state,
@@ -261,23 +257,9 @@ func (b *builder) setReleasesMocks() {
 	b.releases.EXPECT().All().Return(allReleases, nil)
 }
 
-func (b *builder) setDestinationsMocks() {
-	var allDestinations []terra.Destination
-
-	for _, cluster := range b.clusterSet {
-		allDestinations = append(allDestinations, cluster)
-	}
-	for _, env := range b.environmentSet {
-		allDestinations = append(allDestinations, env)
-	}
-
-	b.destinations.EXPECT().All().Return(allDestinations, nil)
-}
-
 func (b *builder) setStateMocks() {
 	b.state.EXPECT().Environments().Return(b.environments)
 	b.state.EXPECT().Clusters().Return(b.clusters)
-	b.state.EXPECT().Destinations().Return(b.destinations)
 	b.state.EXPECT().Releases().Return(b.releases)
 }
 

internal/thelma/state/testing/statefixtures/mocks.go

@@ -8,7 +8,6 @@ import (
 
 type Mocks struct {
 	Clusters     *statemocks.Clusters
-	Destinations *StubDestinations
 	Environments *StubEnvironments
 	Releases     *StubReleases
 	State        *statemocks.State
@@ -45,15 +44,3 @@ func (m *StubEnvironments) Filter(filter terra.EnvironmentFilter) ([]terra.Envir
 	}
 	return filter.Filter(all), nil
 }
-
-type StubDestinations struct {
-	*statemocks.Destinations
-}
-
-func (m *StubDestinations) Filter(filter terra.DestinationFilter) ([]terra.Destination, error) {
-	all, err := m.Destinations.All()
-	if err != nil {
-		return nil, err
-	}
-	return filter.Filter(all), nil
-}