From c8f27d3df414bff6cc810bc15f1c31adee63d8e2 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 22:40:35 -0600 Subject: [PATCH 1/4] fix(up): compose workspace env by target precedence --- cmd/workspace/up/secrets_test.go | 16 ++-- cmd/workspace/up/up_client.go | 45 ++++++++-- cmd/workspace/up/workspace_env.go | 94 ++++++++++++++++++++ cmd/workspace/up/workspace_env_test.go | 114 +++++++++++++++++++++++++ e2e/tests/up/provider_docker.go | 41 +++++++++ pkg/devcontainer/setup/setup.go | 37 ++++++-- pkg/devcontainer/setup/setup_test.go | 65 ++++++++++++++ pkg/options/options_test.go | 10 +++ 8 files changed, 403 insertions(+), 19 deletions(-) create mode 100644 cmd/workspace/up/workspace_env.go create mode 100644 cmd/workspace/up/workspace_env_test.go diff --git a/cmd/workspace/up/secrets_test.go b/cmd/workspace/up/secrets_test.go index 75172a464c..bb887b65ac 100644 --- a/cmd/workspace/up/secrets_test.go +++ b/cmd/workspace/up/secrets_test.go @@ -140,15 +140,17 @@ func TestCollectEnvVarRequests_ContextAttachment(t *testing.T) { got, err := collectEnvVarRequests(nil, testEnvConfig("ZED", "ALPHA")) require.NoError(t, err) assert.Equal(t, []envVarRequest{ - {ref: localRef("ALPHA"), target: "ALPHA"}, - {ref: localRef("ZED"), target: "ZED"}, + {ref: localRef("ALPHA"), target: "ALPHA", origin: envVarAttached}, + {ref: localRef("ZED"), target: "ZED", origin: envVarAttached}, }, got) } func TestCollectEnvVarRequests_ExplicitOverridesAttachment(t *testing.T) { got, err := collectEnvVarRequests([]string{"LOG_LEVEL=APP_LOG"}, testEnvConfig("LOG_LEVEL")) require.NoError(t, err) - assert.Equal(t, []envVarRequest{{ref: localRef("LOG_LEVEL"), target: "APP_LOG"}}, got) + assert.Equal(t, []envVarRequest{{ + ref: localRef("LOG_LEVEL"), target: "APP_LOG", origin: envVarExplicit, + }}, got) } func TestCollectEnvVarRequests_PreservesRepeatedExplicitSource(t *testing.T) { @@ -158,8 +160,8 @@ func TestCollectEnvVarRequests_PreservesRepeatedExplicitSource(t *testing.T) { ) require.NoError(t, err) assert.Equal(t, []envVarRequest{ - {ref: localRef("LOG_LEVEL"), target: "FIRST"}, - {ref: localRef("LOG_LEVEL"), target: "SECOND"}, + {ref: localRef("LOG_LEVEL"), target: "FIRST", origin: envVarExplicit}, + {ref: localRef("LOG_LEVEL"), target: "SECOND", origin: envVarExplicit}, }, got) } @@ -170,8 +172,8 @@ func TestCollectEnvVarRequests_ExplicitRepeatedSourceSuppressesImplicit(t *testi ) require.NoError(t, err) assert.Equal(t, []envVarRequest{ - {ref: localRef("LOG_LEVEL"), target: "FIRST"}, - {ref: localRef("LOG_LEVEL"), target: "SECOND"}, + {ref: localRef("LOG_LEVEL"), target: "FIRST", origin: envVarExplicit}, + {ref: localRef("LOG_LEVEL"), target: "SECOND", origin: envVarExplicit}, }, got) } diff --git a/cmd/workspace/up/up_client.go b/cmd/workspace/up/up_client.go index 544ca93537..d3492cece4 100644 --- a/cmd/workspace/up/up_client.go +++ b/cmd/workspace/up/up_client.go @@ -238,6 +238,9 @@ func (cmd *UpCmd) prepareSecretsWithProject( if err := mergeEnvFromFiles(&cmd.CLIOptions); err != nil { return err } + if _, err := indexWorkspaceEnv(cmd.WorkspaceEnv); err != nil { + return err + } if cmd.SecretsFile != "" { parsed, err := secrets.ParseSecretsFile(cmd.SecretsFile) @@ -354,8 +357,16 @@ func (cmd *UpCmd) applyLifecycleSecrets( type envVarRequest struct { ref secrets.SecretRef target string + origin envVarRequestOrigin } +type envVarRequestOrigin uint8 + +const ( + envVarAttached envVarRequestOrigin = iota + envVarExplicit +) + func collectEnvVarRequests(flags []string, devsyConfig *config.Config) ([]envVarRequest, error) { explicit := make([]envVarRequest, 0, len(flags)) explicitRefs := map[string]struct{}{} @@ -364,6 +375,7 @@ func collectEnvVarRequests(flags []string, devsyConfig *config.Config) ([]envVar if err != nil { return nil, err } + req.origin = envVarExplicit explicit = append(explicit, req) explicitRefs[req.ref.String()] = struct{}{} } @@ -383,7 +395,9 @@ func collectEnvVarRequests(flags []string, devsyConfig *config.Config) ([]envVar if _, overridden := explicitRefs[ref.String()]; overridden { continue } - implicit = append(implicit, envVarRequest{ref: ref, target: ref.Name}) + implicit = append(implicit, envVarRequest{ + ref: ref, target: ref.Name, origin: envVarAttached, + }) } } sort.Slice( @@ -428,11 +442,17 @@ func parseEnvVarRequest(entry string) (envVarRequest, error) { func checkDuplicateEnvTargets(requests []envVarRequest) error { targets := map[string]secrets.SecretRef{} for _, req := range requests { - if previous, ok := targets[req.target]; ok && previous.String() != req.ref.String() { + if previous, ok := targets[req.target]; ok { + if previous.String() != req.ref.String() { + return fmt.Errorf( + "environment variables %q and %q both target %q", + previous.Name, + req.ref.Name, + req.target, + ) + } return fmt.Errorf( - "environment variables %q and %q both target %q", - previous.Name, - req.ref.Name, + "workspace environment variable %q is assigned more than once", req.target, ) } @@ -456,12 +476,25 @@ func (cmd *UpCmd) applyEnvVars( if err := checkDuplicateEnvTargets(requests); err != nil { return err } + base, err := indexWorkspaceEnv(cmd.WorkspaceEnv) + if err != nil { + return err + } + requests, err = filterWorkspaceEnvRequests(base, requests) + if err != nil { + return err + } + resolvedEnv := make([]resolvedEnvVar, 0, len(requests)) for _, req := range requests { envVar, err := resolveEnvVarRequest(ctx, resolver, req) if err != nil { return err } - cmd.WorkspaceEnv = append(cmd.WorkspaceEnv, envVar) + resolvedEnv = append(resolvedEnv, resolvedEnvVar{assignment: envVar}) + } + cmd.WorkspaceEnv, err = composeWorkspaceEnv(base, resolvedEnv) + if err != nil { + return err } return nil } diff --git a/cmd/workspace/up/workspace_env.go b/cmd/workspace/up/workspace_env.go new file mode 100644 index 0000000000..828f623fc4 --- /dev/null +++ b/cmd/workspace/up/workspace_env.go @@ -0,0 +1,94 @@ +package up + +import ( + "fmt" + "sort" + "strings" +) + +type workspaceEnvAssignment struct { + name string + value string +} + +type resolvedEnvVar struct { + assignment string +} + +func parseWorkspaceEnvAssignment(raw string) (workspaceEnvAssignment, error) { + name, value, ok := strings.Cut(raw, "=") + if !ok || name == "" { + return workspaceEnvAssignment{}, fmt.Errorf("invalid workspace environment assignment") + } + return workspaceEnvAssignment{name: name, value: value}, nil +} + +func indexWorkspaceEnv(assignments []string) (map[string]workspaceEnvAssignment, error) { + indexed := make(map[string]workspaceEnvAssignment, len(assignments)) + for _, raw := range assignments { + assignment, err := parseWorkspaceEnvAssignment(raw) + if err != nil { + return nil, err + } + if _, exists := indexed[assignment.name]; exists { + return nil, fmt.Errorf( + "workspace environment variable %q is assigned more than once", + assignment.name, + ) + } + indexed[assignment.name] = assignment + } + return indexed, nil +} + +func filterWorkspaceEnvRequests( + base map[string]workspaceEnvAssignment, + requests []envVarRequest, +) ([]envVarRequest, error) { + filtered := make([]envVarRequest, 0, len(requests)) + for _, request := range requests { + if _, exists := base[request.target]; !exists { + filtered = append(filtered, request) + continue + } + if request.origin == envVarAttached { + continue + } + return nil, fmt.Errorf( + "workspace environment target %q is set by both --workspace-env and --env; remove one explicit assignment", + request.target, + ) + } + return filtered, nil +} + +func composeWorkspaceEnv( + base map[string]workspaceEnvAssignment, + managed []resolvedEnvVar, +) ([]string, error) { + for _, resolved := range managed { + assignment, err := parseWorkspaceEnvAssignment(resolved.assignment) + if err != nil { + return nil, err + } + if _, exists := base[assignment.name]; exists { + return nil, fmt.Errorf( + "workspace environment variable %q is assigned more than once", + assignment.name, + ) + } + base[assignment.name] = assignment + } + + keys := make([]string, 0, len(base)) + for key := range base { + keys = append(keys, key) + } + sort.Strings(keys) + result := make([]string, 0, len(keys)) + for _, key := range keys { + assignment := base[key] + result = append(result, assignment.name+"="+assignment.value) + } + return result, nil +} diff --git a/cmd/workspace/up/workspace_env_test.go b/cmd/workspace/up/workspace_env_test.go new file mode 100644 index 0000000000..2ff1a24f1d --- /dev/null +++ b/cmd/workspace/up/workspace_env_test.go @@ -0,0 +1,114 @@ +package up + +import ( + "context" + "fmt" + "testing" + + secretspkg "github.com/devsy-org/devsy/pkg/secrets" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + workspaceEnvLogLevel = "LOG_LEVEL" + workspaceEnvLiteralAssignment = "LOG_LEVEL=custom-value" +) + +func TestComposeWorkspaceEnv_AttachmentFillsMissingTarget(t *testing.T) { + base, err := indexWorkspaceEnv([]string{"LOCAL=value"}) + require.NoError(t, err) + requests, err := filterWorkspaceEnvRequests(base, []envVarRequest{{ + ref: localRef("ATTACHED"), target: "ATTACHED", origin: envVarAttached, + }}) + require.NoError(t, err) + require.Len(t, requests, 1) + got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{ + assignment: "ATTACHED=managed", + }}) + require.NoError(t, err) + assert.Equal(t, []string{"ATTACHED=managed", "LOCAL=value"}, got) +} + +func TestComposeWorkspaceEnv_LiteralWorkspaceEnvShadowsAttachment(t *testing.T) { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{workspaceEnvLiteralAssignment} + resolver := secretspkg.NewResolver() + require.NoError(t, resolver.Register("local", "local", fixedSource{ + values: map[string]string{workspaceEnvLogLevel: "stored-value"}, + })) + + err := cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver) + require.NoError(t, err) + assert.Equal(t, []string{workspaceEnvLiteralAssignment}, cmd.WorkspaceEnv) +} + +func TestComposeWorkspaceEnv_ShadowingDoesNotDependOnValueLexicalOrder(t *testing.T) { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{workspaceEnvLiteralAssignment} + resolver := secretspkg.NewResolver() + require.NoError(t, resolver.Register("local", "local", fixedSource{ + values: map[string]string{workspaceEnvLogLevel: "stored-value"}, + })) + + require.NoError(t, cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver)) + assert.Equal(t, workspaceEnvLiteralAssignment, cmd.WorkspaceEnv[0]) +} + +func TestComposeWorkspaceEnv_ShadowedAttachmentIsNotResolved(t *testing.T) { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=local"} + resolver := secretspkg.NewResolver() + require.NoError(t, resolver.Register("local", "local", unavailableEnvSource{})) + + err := cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver) + require.NoError(t, err) + assert.Equal(t, []string{workspaceEnvLogLevel + "=local"}, cmd.WorkspaceEnv) +} + +func TestComposeWorkspaceEnv_ExplicitManagedTargetConflictsWithLiteralTarget(t *testing.T) { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{"APP_MODE=local"} + cmd.EnvVars = []string{"STORED_MODE=APP_MODE"} + err := cmd.applyEnvVars(t.Context(), testEnvConfig(), secretspkg.NewResolver()) + require.Error(t, err) + assert.Contains(t, err.Error(), "APP_MODE") + assert.Contains(t, err.Error(), "both --workspace-env and --env") + assert.NotContains(t, err.Error(), "local") + assert.Equal(t, []string{"APP_MODE=local"}, cmd.WorkspaceEnv) +} + +func TestComposeWorkspaceEnv_DuplicateLiteralTargetRejected(t *testing.T) { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{"APP_MODE=a", "APP_MODE=b"} + err := cmd.applyEnvVars(t.Context(), testEnvConfig(), secretspkg.NewResolver()) + require.Error(t, err) + assert.Contains(t, err.Error(), `"APP_MODE"`) + assert.NotContains(t, err.Error(), "=a") + assert.NotContains(t, err.Error(), "=b") +} + +func TestComposeWorkspaceEnv_ValueMayContainEquals(t *testing.T) { + assignment, err := parseWorkspaceEnvAssignment("TOKEN=one=two") + require.NoError(t, err) + assert.Equal(t, workspaceEnvAssignment{name: "TOKEN", value: "one=two"}, assignment) +} + +func TestComposeWorkspaceEnv_OutputHasUniqueTargets(t *testing.T) { + base, err := indexWorkspaceEnv([]string{"A=one"}) + require.NoError(t, err) + got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{ + assignment: "B=two", + }}) + require.NoError(t, err) + assert.Equal(t, []string{"A=one", "B=two"}, got) + indexed, err := indexWorkspaceEnv(got) + require.NoError(t, err) + assert.Len(t, indexed, 2) +} + +type unavailableEnvSource struct{} + +func (unavailableEnvSource) Get(_ context.Context, name string) (secretspkg.ResolvedSecret, error) { + return secretspkg.ResolvedSecret{}, fmt.Errorf("unexpected resolution of %s", name) +} diff --git a/e2e/tests/up/provider_docker.go b/e2e/tests/up/provider_docker.go index f7a822d0a5..a818202e03 100644 --- a/e2e/tests/up/provider_docker.go +++ b/e2e/tests/up/provider_docker.go @@ -780,6 +780,47 @@ var _ = ginkgo.Describe( ginkgo.SpecTimeout(framework.TimeoutShort()), ) + ginkgo.It( + "workspace environment overrides a context-attached managed environment value", + func(ctx context.Context) { + useFileSecretsBackend() + contextName := fmt.Sprintf("managed-env-override-%d", time.Now().UnixNano()) + framework.ExpectNoError(dtc.f.DevsyContextCreate(ctx, contextName)) + ginkgo.DeferCleanup(func(cleanupCtx context.Context) { + _ = dtc.f.DevsyContextUse(cleanupCtx, "default") + _ = dtc.f.DevsyContextDelete(cleanupCtx, contextName) + }) + framework.ExpectNoError(dtc.f.DevsyContextUse(ctx, contextName)) + framework.ExpectNoError( + dtc.f.DevsyProviderAdd(ctx, "docker", "-o", "DOCKER_PATH=docker"), + ) + framework.ExpectNoError(dtc.f.DevsyProviderUse(ctx, "docker")) + + tempDir, err := setupWorkspace( + "tests/up/testdata/docker-managed-env-attached", + dtc.initialDir, + dtc.f, + ) + framework.ExpectNoError(err) + dtc.storeEnv(ctx, "ATTACHED_ENV", "stored-value") + _, err = dtc.f.ExecCommandOutput(ctx, []string{envCmd, "attach", "ATTACHED_ENV"}) + framework.ExpectNoError(err) + + framework.ExpectNoError(dtc.f.DevsyUp( + ctx, tempDir, "--workspace-env", "ATTACHED_ENV=custom-value", + )) + out, err := dtc.execSSH(ctx, tempDir, `bash -l -c 'printf %s "$ATTACHED_ENV"'`) + framework.ExpectNoError(err) + gomega.Expect(strings.TrimSpace(out)).To(gomega.Equal("custom-value")) + + framework.ExpectNoError(dtc.f.DevsyUpRecreate(ctx, tempDir)) + out, err = dtc.execSSH(ctx, tempDir, `bash -l -c 'printf %s "$ATTACHED_ENV"'`) + framework.ExpectNoError(err) + gomega.Expect(strings.TrimSpace(out)).To(gomega.Equal("custom-value")) + }, + ginkgo.SpecTimeout(framework.TimeoutShort()), + ) + ginkgo.It( "context-attached managed secret injects without --secret and is removed after detach", func(ctx context.Context) { diff --git a/pkg/devcontainer/setup/setup.go b/pkg/devcontainer/setup/setup.go index 89f739afc6..a38e52c65d 100644 --- a/pkg/devcontainer/setup/setup.go +++ b/pkg/devcontainer/setup/setup.go @@ -457,22 +457,47 @@ func patchEtcEnvironmentFlags(workspaceEnv []string) error { return nil } - // make sure we sort the strings - sort.Strings(workspaceEnv) + environment, canonical, err := parseWorkspaceEnvironment(workspaceEnv) + if err != nil { + return err + } - // check if we need to update env - exists, err := markerFileExists("patchEtcEnvironmentFlags", strings.Join(workspaceEnv, "\n")) + exists, err := markerFileExists("patchEtcEnvironmentFlags", strings.Join(canonical, "\n")) if err != nil { return err } else if exists { return nil } - // update env - envfile.MergeAndApply(config.ListToObject(workspaceEnv)) + envfile.MergeAndApply(environment) return nil } +func parseWorkspaceEnvironment(assignments []string) (map[string]string, []string, error) { + environment := make(map[string]string, len(assignments)) + keys := make([]string, 0, len(assignments)) + for _, assignment := range assignments { + name, value, ok := strings.Cut(assignment, "=") + if !ok || name == "" { + return nil, nil, fmt.Errorf("invalid workspace environment assignment") + } + if _, exists := environment[name]; exists { + return nil, nil, fmt.Errorf( + "workspace environment variable %q is assigned more than once", + name, + ) + } + environment[name] = value + keys = append(keys, name) + } + sort.Strings(keys) + canonical := make([]string, 0, len(keys)) + for _, name := range keys { + canonical = append(canonical, name+"="+environment[name]) + } + return environment, canonical, nil +} + func patchEtcEnvironment(mergedConfig *config.MergedDevContainerConfig) error { if len(mergedConfig.RemoteEnv) == 0 { return nil diff --git a/pkg/devcontainer/setup/setup_test.go b/pkg/devcontainer/setup/setup_test.go index 5a4f4fae97..8e0527d761 100644 --- a/pkg/devcontainer/setup/setup_test.go +++ b/pkg/devcontainer/setup/setup_test.go @@ -5,6 +5,8 @@ import ( "os" "os/exec" "path/filepath" + "slices" + "strings" "testing" "github.com/devsy-org/devsy/pkg/agent/tunnel" @@ -15,6 +17,12 @@ import ( "google.golang.org/grpc" ) +const ( + workspaceEnvAlphaAssignment = "ALPHA=first" + workspaceEnvTokenAssignment = "TOKEN=one=two" + workspaceEnvZedAssignment = "ZED=last" +) + // TestSecretMountPath_RejectsEscapes ensures only a plain filename is accepted: // path separators, "." / ".." and traversal are rejected so a crafted target // cannot escape SecretsMountDir or write through a symlinked intermediate dir. @@ -152,6 +160,63 @@ func TestWriteResultFileTo_SkipsWriteWhenContentUnchanged(t *testing.T) { } } +func TestParseWorkspaceEnvironment_RejectsDuplicateTarget(t *testing.T) { + _, _, err := parseWorkspaceEnvironment([]string{"MODE=one", "MODE=two"}) + if err == nil || !strings.Contains(err.Error(), `"MODE"`) { + t.Fatalf("expected duplicate MODE error, got %v", err) + } +} + +func TestParseWorkspaceEnvironment_CanonicalizesWithoutChangingInput(t *testing.T) { + assignments := []string{ + workspaceEnvZedAssignment, + workspaceEnvAlphaAssignment, + workspaceEnvTokenAssignment, + } + original := slices.Clone(assignments) + + got, canonical, err := parseWorkspaceEnvironment(assignments) + if err != nil { + t.Fatalf("parseWorkspaceEnvironment: %v", err) + } + if !slices.Equal(assignments, original) { + t.Fatalf("input changed: got %v, want %v", assignments, original) + } + wantCanonical := []string{ + workspaceEnvAlphaAssignment, + workspaceEnvTokenAssignment, + workspaceEnvZedAssignment, + } + if !slices.Equal(canonical, wantCanonical) { + t.Fatalf("canonical = %v, want %v", canonical, wantCanonical) + } + if got["TOKEN"] != "one=two" { + t.Fatalf("TOKEN = %q, want %q", got["TOKEN"], "one=two") + } + _, reorderedCanonical, err := parseWorkspaceEnvironment([]string{ + workspaceEnvTokenAssignment, + workspaceEnvAlphaAssignment, + workspaceEnvZedAssignment, + }) + if err != nil { + t.Fatalf("parse reordered workspace environment: %v", err) + } + if !slices.Equal(canonical, reorderedCanonical) { + t.Fatalf("reordered canonical = %v, want %v", reorderedCanonical, canonical) + } +} + +func TestPatchEtcEnvironmentFlagsRejectsDuplicatesWithoutMutatingInput(t *testing.T) { + assignments := []string{"MODE=one", "MODE=two"} + original := slices.Clone(assignments) + if err := patchEtcEnvironmentFlags(assignments); err == nil { + t.Fatal("expected duplicate target error") + } + if !slices.Equal(assignments, original) { + t.Fatalf("input changed: got %v, want %v", assignments, original) + } +} + func TestWriteResultFileTo_WidensExistingRestrictiveMode(t *testing.T) { path := filepath.Join(t.TempDir(), "result.json") // #nosec G306 -- intentional: simulating a pre-fix file left at 0600 diff --git a/pkg/options/options_test.go b/pkg/options/options_test.go index aaa91ebb93..427905c1e6 100644 --- a/pkg/options/options_test.go +++ b/pkg/options/options_test.go @@ -99,6 +99,16 @@ func TestInheritFromEnvironment(t *testing.T) { } } +func TestInheritFromEnvironment_PreservesWorkspaceAssignment(t *testing.T) { + t.Setenv("GIT_AUTHOR_NAME", "host") + got := InheritFromEnvironment( + []string{"GIT_AUTHOR_NAME=workspace"}, + GitIdentityEnvVars, + "", + ) + assert.DeepEqual(t, got, []string{"GIT_AUTHOR_NAME=workspace"}) +} + func runInheritFromEnvironmentTestCase(t *testing.T, testCase assignmentTestCase) { for _, k := range testCase.NotInEnvironment { err := os.Unsetenv(k) From fb5d08bef1b2ba4412f26601d5133d30001865dc Mon Sep 17 00:00:00 2001 From: Samuel K <69881238+skevetter@users.noreply.github.com> Date: Sun, 27 Sep 2026 01:12:47 -0600 Subject: [PATCH 2/4] test(up): reapply workspace env override on recreate --- e2e/tests/up/provider_docker.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/e2e/tests/up/provider_docker.go b/e2e/tests/up/provider_docker.go index a818202e03..8bcc2fc852 100644 --- a/e2e/tests/up/provider_docker.go +++ b/e2e/tests/up/provider_docker.go @@ -813,7 +813,12 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) gomega.Expect(strings.TrimSpace(out)).To(gomega.Equal("custom-value")) - framework.ExpectNoError(dtc.f.DevsyUpRecreate(ctx, tempDir)) + framework.ExpectNoError(dtc.f.DevsyUpRecreate( + ctx, + tempDir, + "--workspace-env", + "ATTACHED_ENV=custom-value", + )) out, err = dtc.execSSH(ctx, tempDir, `bash -l -c 'printf %s "$ATTACHED_ENV"'`) framework.ExpectNoError(err) gomega.Expect(strings.TrimSpace(out)).To(gomega.Equal("custom-value")) From f9bf4dd44eb7dc435e45df8ebdebf58763eab0ad Mon Sep 17 00:00:00 2001 From: Samuel K <69881238+skevetter@users.noreply.github.com> Date: Sun, 27 Sep 2026 20:19:11 -0600 Subject: [PATCH 3/4] test(up): address workspace env review feedback --- cmd/workspace/up/workspace_env_test.go | 104 ++++++++++++++----------- pkg/devcontainer/setup/setup_test.go | 52 +++++-------- pkg/options/options_test.go | 15 +++- 3 files changed, 91 insertions(+), 80 deletions(-) diff --git a/cmd/workspace/up/workspace_env_test.go b/cmd/workspace/up/workspace_env_test.go index 2ff1a24f1d..5b3a92b47b 100644 --- a/cmd/workspace/up/workspace_env_test.go +++ b/cmd/workspace/up/workspace_env_test.go @@ -6,8 +6,7 @@ import ( "testing" secretspkg "github.com/devsy-org/devsy/pkg/secrets" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" ) const ( @@ -15,96 +14,109 @@ const ( workspaceEnvLiteralAssignment = "LOG_LEVEL=custom-value" ) -func TestComposeWorkspaceEnv_AttachmentFillsMissingTarget(t *testing.T) { +type WorkspaceEnvTestSuite struct { + suite.Suite +} + +func TestWorkspaceEnvTestSuite(t *testing.T) { + suite.Run(t, new(WorkspaceEnvTestSuite)) +} + +func (s *WorkspaceEnvTestSuite) TestAttachmentFillsMissingTarget() { base, err := indexWorkspaceEnv([]string{"LOCAL=value"}) - require.NoError(t, err) + s.Require().NoError(err) requests, err := filterWorkspaceEnvRequests(base, []envVarRequest{{ ref: localRef("ATTACHED"), target: "ATTACHED", origin: envVarAttached, }}) - require.NoError(t, err) - require.Len(t, requests, 1) + s.Require().NoError(err) + s.Require().Len(requests, 1) got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{ assignment: "ATTACHED=managed", }}) - require.NoError(t, err) - assert.Equal(t, []string{"ATTACHED=managed", "LOCAL=value"}, got) + s.Require().NoError(err) + s.Assert().Equal([]string{"ATTACHED=managed", "LOCAL=value"}, got) } -func TestComposeWorkspaceEnv_LiteralWorkspaceEnvShadowsAttachment(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestLiteralWorkspaceEnvShadowsAttachment() { cmd := &UpCmd{} cmd.WorkspaceEnv = []string{workspaceEnvLiteralAssignment} resolver := secretspkg.NewResolver() - require.NoError(t, resolver.Register("local", "local", fixedSource{ + s.Require().NoError(resolver.Register("local", "local", fixedSource{ values: map[string]string{workspaceEnvLogLevel: "stored-value"}, })) - err := cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver) - require.NoError(t, err) - assert.Equal(t, []string{workspaceEnvLiteralAssignment}, cmd.WorkspaceEnv) + err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(workspaceEnvLogLevel), resolver) + s.Require().NoError(err) + s.Assert().Equal([]string{workspaceEnvLiteralAssignment}, cmd.WorkspaceEnv) } -func TestComposeWorkspaceEnv_ShadowingDoesNotDependOnValueLexicalOrder(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestShadowingDoesNotDependOnValueLexicalOrder() { cmd := &UpCmd{} - cmd.WorkspaceEnv = []string{workspaceEnvLiteralAssignment} + cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=stored-value"} resolver := secretspkg.NewResolver() - require.NoError(t, resolver.Register("local", "local", fixedSource{ - values: map[string]string{workspaceEnvLogLevel: "stored-value"}, + s.Require().NoError(resolver.Register("local", "local", fixedSource{ + values: map[string]string{workspaceEnvLogLevel: "custom-value"}, })) - require.NoError(t, cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver)) - assert.Equal(t, workspaceEnvLiteralAssignment, cmd.WorkspaceEnv[0]) + err := cmd.applyEnvVars( + s.T().Context(), + testEnvConfig(workspaceEnvLogLevel), + resolver, + ) + s.Require().NoError(err) + s.Assert().Equal([]string{workspaceEnvLogLevel + "=stored-value"}, cmd.WorkspaceEnv) } -func TestComposeWorkspaceEnv_ShadowedAttachmentIsNotResolved(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestShadowedAttachmentIsNotResolved() { cmd := &UpCmd{} cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=local"} resolver := secretspkg.NewResolver() - require.NoError(t, resolver.Register("local", "local", unavailableEnvSource{})) + s.Require().NoError(resolver.Register("local", "local", unavailableEnvSource{})) - err := cmd.applyEnvVars(t.Context(), testEnvConfig(workspaceEnvLogLevel), resolver) - require.NoError(t, err) - assert.Equal(t, []string{workspaceEnvLogLevel + "=local"}, cmd.WorkspaceEnv) + err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(workspaceEnvLogLevel), resolver) + s.Require().NoError(err) + s.Assert().Equal([]string{workspaceEnvLogLevel + "=local"}, cmd.WorkspaceEnv) } -func TestComposeWorkspaceEnv_ExplicitManagedTargetConflictsWithLiteralTarget(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestExplicitManagedTargetConflictsWithLiteralTarget() { cmd := &UpCmd{} cmd.WorkspaceEnv = []string{"APP_MODE=local"} cmd.EnvVars = []string{"STORED_MODE=APP_MODE"} - err := cmd.applyEnvVars(t.Context(), testEnvConfig(), secretspkg.NewResolver()) - require.Error(t, err) - assert.Contains(t, err.Error(), "APP_MODE") - assert.Contains(t, err.Error(), "both --workspace-env and --env") - assert.NotContains(t, err.Error(), "local") - assert.Equal(t, []string{"APP_MODE=local"}, cmd.WorkspaceEnv) + err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(), secretspkg.NewResolver()) + s.Require().Error(err) + s.Assert().Contains(err.Error(), "APP_MODE") + s.Assert().Contains(err.Error(), "both --workspace-env and --env") + s.Assert().NotContains(err.Error(), "local") + s.Assert().Equal([]string{"APP_MODE=local"}, cmd.WorkspaceEnv) } -func TestComposeWorkspaceEnv_DuplicateLiteralTargetRejected(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestDuplicateLiteralTargetRejected() { cmd := &UpCmd{} cmd.WorkspaceEnv = []string{"APP_MODE=a", "APP_MODE=b"} - err := cmd.applyEnvVars(t.Context(), testEnvConfig(), secretspkg.NewResolver()) - require.Error(t, err) - assert.Contains(t, err.Error(), `"APP_MODE"`) - assert.NotContains(t, err.Error(), "=a") - assert.NotContains(t, err.Error(), "=b") + err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(), secretspkg.NewResolver()) + s.Require().Error(err) + s.Assert().Contains(err.Error(), `"APP_MODE"`) + s.Assert().NotContains(err.Error(), "=a") + s.Assert().NotContains(err.Error(), "=b") } -func TestComposeWorkspaceEnv_ValueMayContainEquals(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestValueMayContainEquals() { assignment, err := parseWorkspaceEnvAssignment("TOKEN=one=two") - require.NoError(t, err) - assert.Equal(t, workspaceEnvAssignment{name: "TOKEN", value: "one=two"}, assignment) + s.Require().NoError(err) + s.Assert().Equal(workspaceEnvAssignment{name: "TOKEN", value: "one=two"}, assignment) } -func TestComposeWorkspaceEnv_OutputHasUniqueTargets(t *testing.T) { +func (s *WorkspaceEnvTestSuite) TestOutputHasUniqueTargets() { base, err := indexWorkspaceEnv([]string{"A=one"}) - require.NoError(t, err) + s.Require().NoError(err) got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{ assignment: "B=two", }}) - require.NoError(t, err) - assert.Equal(t, []string{"A=one", "B=two"}, got) + s.Require().NoError(err) + s.Assert().Equal([]string{"A=one", "B=two"}, got) indexed, err := indexWorkspaceEnv(got) - require.NoError(t, err) - assert.Len(t, indexed, 2) + s.Require().NoError(err) + s.Assert().Len(indexed, 2) } type unavailableEnvSource struct{} diff --git a/pkg/devcontainer/setup/setup_test.go b/pkg/devcontainer/setup/setup_test.go index 8e0527d761..1eed322ead 100644 --- a/pkg/devcontainer/setup/setup_test.go +++ b/pkg/devcontainer/setup/setup_test.go @@ -6,13 +6,13 @@ import ( "os/exec" "path/filepath" "slices" - "strings" "testing" "github.com/devsy-org/devsy/pkg/agent/tunnel" pkgconfig "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/log" + "github.com/stretchr/testify/suite" "go.uber.org/zap/zapcore" "google.golang.org/grpc" ) @@ -160,14 +160,20 @@ func TestWriteResultFileTo_SkipsWriteWhenContentUnchanged(t *testing.T) { } } -func TestParseWorkspaceEnvironment_RejectsDuplicateTarget(t *testing.T) { +type WorkspaceEnvironmentTestSuite struct { + suite.Suite +} + +func TestWorkspaceEnvironmentTestSuite(t *testing.T) { + suite.Run(t, new(WorkspaceEnvironmentTestSuite)) +} + +func (s *WorkspaceEnvironmentTestSuite) TestParseRejectsDuplicateTarget() { _, _, err := parseWorkspaceEnvironment([]string{"MODE=one", "MODE=two"}) - if err == nil || !strings.Contains(err.Error(), `"MODE"`) { - t.Fatalf("expected duplicate MODE error, got %v", err) - } + s.Require().ErrorContains(err, `"MODE"`) } -func TestParseWorkspaceEnvironment_CanonicalizesWithoutChangingInput(t *testing.T) { +func (s *WorkspaceEnvironmentTestSuite) TestParseCanonicalizesWithoutChangingInput() { assignments := []string{ workspaceEnvZedAssignment, workspaceEnvAlphaAssignment, @@ -176,45 +182,29 @@ func TestParseWorkspaceEnvironment_CanonicalizesWithoutChangingInput(t *testing. original := slices.Clone(assignments) got, canonical, err := parseWorkspaceEnvironment(assignments) - if err != nil { - t.Fatalf("parseWorkspaceEnvironment: %v", err) - } - if !slices.Equal(assignments, original) { - t.Fatalf("input changed: got %v, want %v", assignments, original) - } + s.Require().NoError(err) + s.Assert().Equal(original, assignments) wantCanonical := []string{ workspaceEnvAlphaAssignment, workspaceEnvTokenAssignment, workspaceEnvZedAssignment, } - if !slices.Equal(canonical, wantCanonical) { - t.Fatalf("canonical = %v, want %v", canonical, wantCanonical) - } - if got["TOKEN"] != "one=two" { - t.Fatalf("TOKEN = %q, want %q", got["TOKEN"], "one=two") - } + s.Assert().Equal(wantCanonical, canonical) + s.Assert().Equal("one=two", got["TOKEN"]) _, reorderedCanonical, err := parseWorkspaceEnvironment([]string{ workspaceEnvTokenAssignment, workspaceEnvAlphaAssignment, workspaceEnvZedAssignment, }) - if err != nil { - t.Fatalf("parse reordered workspace environment: %v", err) - } - if !slices.Equal(canonical, reorderedCanonical) { - t.Fatalf("reordered canonical = %v, want %v", reorderedCanonical, canonical) - } + s.Require().NoError(err) + s.Assert().Equal(canonical, reorderedCanonical) } -func TestPatchEtcEnvironmentFlagsRejectsDuplicatesWithoutMutatingInput(t *testing.T) { +func (s *WorkspaceEnvironmentTestSuite) TestPatchRejectsDuplicatesWithoutMutatingInput() { assignments := []string{"MODE=one", "MODE=two"} original := slices.Clone(assignments) - if err := patchEtcEnvironmentFlags(assignments); err == nil { - t.Fatal("expected duplicate target error") - } - if !slices.Equal(assignments, original) { - t.Fatalf("input changed: got %v, want %v", assignments, original) - } + s.Require().Error(patchEtcEnvironmentFlags(assignments)) + s.Assert().Equal(original, assignments) } func TestWriteResultFileTo_WidensExistingRestrictiveMode(t *testing.T) { diff --git a/pkg/options/options_test.go b/pkg/options/options_test.go index 427905c1e6..3406dc5811 100644 --- a/pkg/options/options_test.go +++ b/pkg/options/options_test.go @@ -4,6 +4,7 @@ import ( "os" "testing" + "github.com/stretchr/testify/suite" "gotest.tools/assert" ) @@ -99,14 +100,22 @@ func TestInheritFromEnvironment(t *testing.T) { } } -func TestInheritFromEnvironment_PreservesWorkspaceAssignment(t *testing.T) { - t.Setenv("GIT_AUTHOR_NAME", "host") +type InheritFromEnvironmentTestSuite struct { + suite.Suite +} + +func TestInheritFromEnvironmentTestSuite(t *testing.T) { + suite.Run(t, new(InheritFromEnvironmentTestSuite)) +} + +func (s *InheritFromEnvironmentTestSuite) TestPreservesWorkspaceAssignment() { + s.T().Setenv("GIT_AUTHOR_NAME", "host") got := InheritFromEnvironment( []string{"GIT_AUTHOR_NAME=workspace"}, GitIdentityEnvVars, "", ) - assert.DeepEqual(t, got, []string{"GIT_AUTHOR_NAME=workspace"}) + s.Assert().Equal([]string{"GIT_AUTHOR_NAME=workspace"}, got) } func runInheritFromEnvironmentTestCase(t *testing.T, testCase assignmentTestCase) { From 70dcc74cacc20a24ee92c49816bd8b04de0277e0 Mon Sep 17 00:00:00 2001 From: Samuel K <69881238+skevetter@users.noreply.github.com> Date: Sun, 27 Sep 2026 22:21:10 -0600 Subject: [PATCH 4/4] fix(up): filter shadowed env attachments first --- cmd/workspace/up/up_client.go | 6 +++--- cmd/workspace/up/workspace_env_test.go | 12 ++++++++++++ 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/cmd/workspace/up/up_client.go b/cmd/workspace/up/up_client.go index d3492cece4..450feb8ed9 100644 --- a/cmd/workspace/up/up_client.go +++ b/cmd/workspace/up/up_client.go @@ -473,9 +473,6 @@ func (cmd *UpCmd) applyEnvVars( if err != nil { return err } - if err := checkDuplicateEnvTargets(requests); err != nil { - return err - } base, err := indexWorkspaceEnv(cmd.WorkspaceEnv) if err != nil { return err @@ -484,6 +481,9 @@ func (cmd *UpCmd) applyEnvVars( if err != nil { return err } + if err := checkDuplicateEnvTargets(requests); err != nil { + return err + } resolvedEnv := make([]resolvedEnvVar, 0, len(requests)) for _, req := range requests { envVar, err := resolveEnvVarRequest(ctx, resolver, req) diff --git a/cmd/workspace/up/workspace_env_test.go b/cmd/workspace/up/workspace_env_test.go index 5b3a92b47b..94b0fcbd24 100644 --- a/cmd/workspace/up/workspace_env_test.go +++ b/cmd/workspace/up/workspace_env_test.go @@ -78,6 +78,18 @@ func (s *WorkspaceEnvTestSuite) TestShadowedAttachmentIsNotResolved() { s.Assert().Equal([]string{workspaceEnvLogLevel + "=local"}, cmd.WorkspaceEnv) } +func (s *WorkspaceEnvTestSuite) TestDuplicateShadowedAttachmentsAreIgnored() { + cmd := &UpCmd{} + cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=local"} + err := cmd.applyEnvVars( + s.T().Context(), + testEnvConfig(workspaceEnvLogLevel, workspaceEnvLogLevel), + secretspkg.NewResolver(), + ) + s.Require().NoError(err) + s.Assert().Equal([]string{workspaceEnvLogLevel + "=local"}, cmd.WorkspaceEnv) +} + func (s *WorkspaceEnvTestSuite) TestExplicitManagedTargetConflictsWithLiteralTarget() { cmd := &UpCmd{} cmd.WorkspaceEnv = []string{"APP_MODE=local"}