deploy/cloud/operator/internal/consts/consts.go (1)

70-72: Consider aligning the constant name with existing Env-prefixed naming scheme

Most environment-variable constants in this file follow the pattern Env<Something>.
DynamoDeploymentConfigEnvVar is functionally correct, but it slightly breaks the naming consistency and makes “what is an env-var vs. a plain constant” harder to grep for.

-	DynamoDeploymentConfigEnvVar = "DYN_DEPLOYMENT_CONFIG"
+	EnvDynamoDeploymentConfig = "DYN_DEPLOYMENT_CONFIG"

Renaming now will avoid future churn, because this identifier will quickly propagate throughout the codebase.

deploy/cloud/operator/api/v1alpha1/dynamocomponentdeployment_types.go (1)

180-191: Setter overwrites but never removes the env-var

SetDynamoDeploymentConfig(nil) is currently a no-op and leaves the last value in place.
If the caller wants to “clear” the config, there is no API.

Either:

1. Document that nil is not supported, or
2. Treat len(config)==0 as a delete request:

 if len(config) == 0 {
     // delete existing entry
     for i, env := range s.Spec.Envs {
         if env.Name == commonconsts.DynamoDeploymentConfigEnvVar {
             s.Spec.Envs = append(s.Spec.Envs[:i], s.Spec.Envs[i+1:]...)
             return
         }
     }
 }

deploy/cloud/operator/api/v1alpha1/dynamocomponentdeployment_types_test.go (2)

131-134: Prefer bytes.Equal for byte-slice comparison

reflect.DeepEqual works but is slower and less explicit than bytes.Equal for raw byte slices.

- if got := s.GetDynamoDeploymentConfig(); !reflect.DeepEqual(got, tt.want) {
+ if got := s.GetDynamoDeploymentConfig(); !bytes.Equal(got, tt.want) {

(or convert both to string and compare).
This keeps intent crystal-clear and avoids accidental misuse when the type changes.

---

207-209: Test resilience: order-sensitive comparison of Envs slice

The assertion compares the entire slice literally. If unrelated env-vars are appended elsewhere in the code, this test will start failing even though SetDynamoDeploymentConfig still behaves correctly.

A more future-proof check:

var found bool
for _, e := range s.Spec.DynamoComponentDeploymentSharedSpec.Envs {
    if e.Name == commonconsts.DynamoDeploymentConfigEnvVar &&
       e.Value == string(tt.args.config) {
        found = true
        break
    }
}
if !found {
    t.Fatalf("env %s not set to expected value", commonconsts.DynamoDeploymentConfigEnvVar)
}

deploy/cloud/operator/internal/dynamo/graph.go (1)

512-531: mergeEnvs loses deterministic order

Using a map provides O(1) overrides but produces non-deterministic
ordering, which complicates diffing and may surprise users inspecting
the CR. A stable order (specific first, then common sorted) costs very
little:

func mergeEnvs(common, specific []corev1.EnvVar) []corev1.EnvVar {
    seen := map[string]struct{}{}
    merged := make([]corev1.EnvVar, 0, len(common)+len(specific))

    // keep specific order
    for _, e := range specific {
        merged = append(merged, e)
        seen[e.Name] = struct{}{}
    }
    // append remaining common envs alphabetically
    sort.Slice(common, func(i,j int) bool { return common[i].Name < common[j].Name })
    for _, e := range common {
        if _, ok := seen[e.Name]; !ok {
            merged = append(merged, e)
        }
    }
    return merged
}

deploy/cloud/operator/internal/dynamo/graph_test.go (1)

1832-1838: Sort both slices (want & got) to avoid order-dependent failures

mergeEnvs now returns a non-deterministic order (map iteration).
The test sorts only the got slice; if want is declared out of alpha
order the comparison fails spuriously.

- sort.Slice(got, func(i, j int) bool { return got[i].Name < got[j].Name })
+ sort.Slice(got,  func(i, j int) bool { return got[i].Name < got[j].Name })
+ sort.Slice(tt.want, func(i, j int) bool { return tt.want[i].Name < tt.want[j].Name })

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro