remove unassigned targets from deployment

api/pkg/apis/v1alpha1/managers/solution/solution-manager-state.go

@@ -7,6 +7,7 @@
 package solution
 
 import (
+	"encoding/json"
 	"fmt"
 	"sort"
 	"strings"
@@ -52,6 +53,11 @@ func PlanForDeployment(deployment model.DeploymentSpec, state model.DeploymentSt
 			}
 		}
 	}
+	test := ret.RevisedForDeletion()
+	jTestData, _ := json.Marshal(test)
+	fmt.Println("--------------------------------------------------")
+	fmt.Println(string(jTestData))
+	fmt.Println("--------------------------------------------------")
 	return ret.RevisedForDeletion(), nil
 }
 

api/pkg/apis/v1alpha1/utils/symphony-api.go

@@ -773,14 +773,21 @@ func CreateSymphonyDeployment(instance model.InstanceState, solution model.Solut
 		ret.Assignments[k] = v
 	}
 
+	// Remove targets not in assignments
+	for targetName := range ret.Targets {
+		if _, ok := ret.Assignments[targetName]; !ok {
+			delete(ret.Targets, targetName)
+		}
+	}
+
 	return ret, nil
 }
 
 func AssignComponentsToTargets(components []model.ComponentSpec, targets map[string]model.TargetState) (map[string]string, error) {
 	//TODO: evaluate constraints
 	ret := make(map[string]string)
 	for key, target := range targets {
-		ret[key] = ""
+		assignments := ""
 		for _, component := range components {
 			match := true
 			if component.Constraints != "" {
@@ -794,9 +801,13 @@ func AssignComponentsToTargets(components []model.ComponentSpec, targets map[str
 				match = (val == "true" || val == true)
 			}
 			if match {
-				ret[key] += "{" + component.Name + "}"
+				assignments += "{" + component.Name + "}"
 			}
 		}
+		// Only add the key to the map if assignments is not empty
+		if assignments != "" {
+			ret[key] = assignments
+		}
 	}
 
 	return ret, nil

api/pkg/apis/v1alpha1/utils/symphony-api_test.go

@@ -644,6 +644,65 @@ func TestCreateSymphonyDeploymentFromTarget(t *testing.T) {
 	require.True(t, ret)
 }
 
+func TestCreateSymphonyDeploymentTargetTrim(t *testing.T) {
+	res, err := CreateSymphonyDeployment(model.InstanceState{
+		ObjectMeta: model.ObjectMeta{
+			Name: "someInstance",
+		},
+		Spec: &model.InstanceSpec{
+			Target: model.TargetSelector{
+				Selector: map[string]string{
+					"OS": "windows",
+				},
+			},
+		},
+		Status: model.InstanceStatus{},
+	}, model.SolutionState{
+		ObjectMeta: model.ObjectMeta{
+			Name: "someSolution",
+		},
+		Spec: &model.SolutionSpec{
+			Components: []model.ComponentSpec{
+				{
+					Name:        "com1",
+					Type:        "type1",
+					Constraints: "${{$equal($property(OS),windows)}}",
+				},
+				{
+					Name:        "com2",
+					Type:        "type2",
+					Constraints: "${{$equal($property(OS),windows)}}",
+				},
+			},
+		},
+	}, []model.TargetState{
+		{
+			ObjectMeta: model.ObjectMeta{
+				Name: "target1",
+			},
+			Spec: &model.TargetSpec{
+				Properties: map[string]string{
+					"OS": "windows",
+				},
+			},
+		},
+		{
+			ObjectMeta: model.ObjectMeta{
+				Name: "target2",
+			},
+			Spec: &model.TargetSpec{
+				Properties: map[string]string{
+					"OS": "linux",
+				},
+			},
+		},
+	}, []model.DeviceState{}, "default")
+	require.NoError(t, err)
+	// If a target is not assigned, it should be excluded in the final deployment
+	require.Equal(t, 1, len(res.Targets))
+	require.Equal(t, 1, len(res.Assignments))
+}
+
 func TestCreateSymphonyDeployment(t *testing.T) {
 	res, err := CreateSymphonyDeployment(model.InstanceState{
 		ObjectMeta: model.ObjectMeta{