refactor(target): unify target setters and make overlays idempotent

Direct setters (TargetGarden/Project/Seed/Shoot/ControlPlane) and
pattern targeting now converge on a single applyOverlay path that
performs merge, validation, enrichment, and access-restriction
prompts. The separate target_builder is removed.

Command-lifetime idempotency moves from the provider into the
manager: CurrentTarget caches the effective target and writes
update the cache through one updateTarget path, so repeated reads
no longer reapply CLI flags onto freshly written state.

Pattern targeting reads the raw persisted target once, merges CLI
and pattern flags into one overlay with conflict detection, and
runs validation a single time on the finalized target.

Author: petersutter

internal/fake/target_provider.go

@@ -35,6 +35,12 @@ func (p *TargetProvider) Read() (target.Target, error) {
 	return p.Target, nil
 }
 
+// ReadPersisted returns the target as persisted. The fake provider has no
+// command-local overlays, so this is identical to Read.
+func (p *TargetProvider) ReadPersisted() (target.Target, error) {
+	return p.Read()
+}
+
 // Write takes a target and saves it permanently.
 func (p *TargetProvider) Write(t target.Target) error {
 	p.Target = t

internal/util/factory.go

@@ -81,6 +81,10 @@ type FactoryImpl struct {
 	// targetFlags can be used to completely override the target configuration
 	// stored on the filesystem via a CLI flags.
 	targetFlags target.TargetFlags
+
+	// ClientProvider overrides the Kubernetes client provider used by Manager.
+	// If unset, Manager uses the real provider.
+	ClientProvider internalclient.Provider
 }
 
 var _ Factory = &FactoryImpl{}
@@ -133,7 +137,11 @@ func (f *FactoryImpl) Manager() (target.Manager, error) {
 	}
 
 	targetProvider := target.NewTargetProvider(filepath.Join(sessionDirectory, "target.yaml"), f.targetFlags)
-	clientProvider := internalclient.NewProvider()
+
+	clientProvider := f.ClientProvider
+	if clientProvider == nil {
+		clientProvider = internalclient.NewProvider()
+	}
 
 	return target.NewManager(cfg, targetProvider, clientProvider, sessionDirectory, f.KubeconfigAccessLevel)
 }

pkg/cmd/providerenv/options.go

@@ -348,6 +348,7 @@ func (o *options) Run(f util.Factory) error {
 	}
 
 	requiresAccessRestrictionConfirmation := false
+
 	if o.TargetFlags != nil {
 		controlPlaneRequested := o.TargetFlags.ControlPlane().Provided() && o.TargetFlags.ControlPlane().Value()
 		requiresAccessRestrictionConfirmation = o.TargetFlags.ShootName() != "" || controlPlaneRequested

pkg/cmd/target/target_test.go

@@ -281,7 +281,7 @@ var _ = Describe("Target Command", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(currentTarget.GardenName()).To(Equal(gardenName))
 			Expect(currentTarget.ProjectName()).To(Equal(projectName))
-			Expect(currentTarget.SeedName()).To(BeEmpty())
+			Expect(currentTarget.SeedName()).To(Equal(seedName))
 			Expect(currentTarget.ShootName()).To(Equal(shootName))
 			Expect(currentTarget.ControlPlane()).To(BeTrue())
 		})

pkg/flags/target_test.go

@@ -265,10 +265,22 @@ var _ = Describe("Target flags", func() {
 	})
 
 	Describe("Depending on the factory implementation", func() {
-		var factory *util.FactoryImpl
+		var (
+			ctrl           *gomock.Controller
+			clientProvider *clientmocks.MockProvider
+			factory        *util.FactoryImpl
+		)
 
 		BeforeEach(func() {
+			ctrl = gomock.NewController(GinkgoT())
+			clientProvider = clientmocks.NewMockProvider(ctrl)
+
 			factory = util.NewFactoryImpl()
+			factory.ClientProvider = clientProvider
+		})
+
+		AfterEach(func() {
+			ctrl.Finish()
 		})
 
 		Context("when wrapping completion functions", func() {
@@ -312,7 +324,36 @@ var _ = Describe("Target flags", func() {
 
 		Context("when running a command with target flags", func() {
 			It("should override current target", func() {
+				seedName := "test-seed1"
 				shootName := "newshoot"
+				testProject := &gardencorev1beta1.Project{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: projectName,
+						UID:  "00000000-0000-0000-0000-000000000000",
+					},
+					Spec: gardencorev1beta1.ProjectSpec{
+						Namespace: ptr.To("garden-" + projectName),
+					},
+				}
+				testSeed := &gardencorev1beta1.Seed{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: seedName,
+						UID:  "00000000-0000-0000-0000-000000000000",
+					},
+				}
+				testShoot := &gardencorev1beta1.Shoot{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      shootName,
+						Namespace: *testProject.Spec.Namespace,
+						UID:       "00000000-0000-0000-0000-000000000000",
+					},
+					Spec: gardencorev1beta1.ShootSpec{
+						SeedName: ptr.To(seedName),
+					},
+				}
+				gardenClient := fake.NewClientWithObjects(testProject, testSeed, testShoot)
+				clientProvider.EXPECT().FromClientConfig(gomock.Any()).Return(gardenClient, nil).AnyTimes()
+
 				args := []string{
 					fmt.Sprintf("--shoot=%s", shootName),
 					"target",
@@ -326,23 +367,24 @@ var _ = Describe("Target flags", func() {
 				Expect(factory.ConfigFile).To(Equal(configFile))
 				Expect(factory.GardenHomeDirectory).To(Equal(gardenHomeDir))
 
-				manager, err := factory.Manager()
-				Expect(err).NotTo(HaveOccurred())
-
 				// check target flags values
 				tf := factory.TargetFlags()
 				Expect(tf.GardenName()).To(BeEmpty())
 				Expect(tf.ProjectName()).To(BeEmpty())
 				Expect(tf.SeedName()).To(BeEmpty())
 				Expect(tf.ShootName()).To(Equal(shootName))
+				Expect(tf.ControlPlane().Provided()).To(BeFalse())
+				Expect(tf.ControlPlane().Value()).To(BeFalse())
 
-				// check current target values
-				current, err := manager.CurrentTarget()
+				// check persisted target values
+				targetProvider := target.NewTargetProvider(filepath.Join(sessionDir, "target.yaml"), nil)
+				current, err := targetProvider.Read()
 				Expect(err).NotTo(HaveOccurred())
 				Expect(current.GardenName()).To(Equal(gardenName1))
 				Expect(current.ProjectName()).To(Equal(projectName))
-				Expect(current.SeedName()).To(BeEmpty())
+				Expect(current.SeedName()).To(Equal(seedName))
 				Expect(current.ShootName()).To(Equal(shootName))
+				Expect(current.ControlPlane()).To(BeTrue())
 			})
 		})
 	})