Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 9 additions & 7 deletions cmd/workspace/up/secrets_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand All @@ -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)
}

Expand All @@ -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)
}

Expand Down
45 changes: 39 additions & 6 deletions cmd/workspace/up/up_client.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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{}{}
Expand All @@ -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{}{}
}
Expand All @@ -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(
Expand Down Expand Up @@ -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,
)
}
Expand All @@ -453,15 +473,28 @@ func (cmd *UpCmd) applyEnvVars(
if err != nil {
return err
}
base, err := indexWorkspaceEnv(cmd.WorkspaceEnv)
if err != nil {
return err
}
requests, err = filterWorkspaceEnvRequests(base, requests)
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
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)
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
}
Expand Down
94 changes: 94 additions & 0 deletions cmd/workspace/up/workspace_env.go
Original file line number Diff line number Diff line change
@@ -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
}
138 changes: 138 additions & 0 deletions cmd/workspace/up/workspace_env_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,138 @@
package up

import (
"context"
"fmt"
"testing"

secretspkg "github.com/devsy-org/devsy/pkg/secrets"
"github.com/stretchr/testify/suite"
)

const (
workspaceEnvLogLevel = "LOG_LEVEL"
workspaceEnvLiteralAssignment = "LOG_LEVEL=custom-value"
)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Tests bypass preferred suite pattern The new workspace-environment tests use standalone Test functions, as do the added tests in pkg/devcontainer/setup/setup_test.go and pkg/options/options_test.go. The repository guide says to prefer testify/suite for unit tests. This repository requirement should be satisfied before merging.

Context Used: AGENTS.md (source)

Note: If this suggestion doesn't match your team's coding style, reply to this and let me know. I'll remember it for next time!

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"})
s.Require().NoError(err)
requests, err := filterWorkspaceEnvRequests(base, []envVarRequest{{
ref: localRef("ATTACHED"), target: "ATTACHED", origin: envVarAttached,
}})
s.Require().NoError(err)
s.Require().Len(requests, 1)
got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{
assignment: "ATTACHED=managed",
}})
s.Require().NoError(err)
s.Assert().Equal([]string{"ATTACHED=managed", "LOCAL=value"}, got)
}

func (s *WorkspaceEnvTestSuite) TestLiteralWorkspaceEnvShadowsAttachment() {
cmd := &UpCmd{}
cmd.WorkspaceEnv = []string{workspaceEnvLiteralAssignment}
resolver := secretspkg.NewResolver()
s.Require().NoError(resolver.Register("local", "local", fixedSource{
values: map[string]string{workspaceEnvLogLevel: "stored-value"},
}))

err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(workspaceEnvLogLevel), resolver)
s.Require().NoError(err)
s.Assert().Equal([]string{workspaceEnvLiteralAssignment}, cmd.WorkspaceEnv)
}

func (s *WorkspaceEnvTestSuite) TestShadowingDoesNotDependOnValueLexicalOrder() {
cmd := &UpCmd{}
cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=stored-value"}
resolver := secretspkg.NewResolver()
s.Require().NoError(resolver.Register("local", "local", fixedSource{
values: map[string]string{workspaceEnvLogLevel: "custom-value"},
}))

err := cmd.applyEnvVars(
s.T().Context(),
testEnvConfig(workspaceEnvLogLevel),
resolver,
)
s.Require().NoError(err)
s.Assert().Equal([]string{workspaceEnvLogLevel + "=stored-value"}, cmd.WorkspaceEnv)
}

func (s *WorkspaceEnvTestSuite) TestShadowedAttachmentIsNotResolved() {
cmd := &UpCmd{}
cmd.WorkspaceEnv = []string{workspaceEnvLogLevel + "=local"}
resolver := secretspkg.NewResolver()
s.Require().NoError(resolver.Register("local", "local", unavailableEnvSource{}))

err := cmd.applyEnvVars(s.T().Context(), testEnvConfig(workspaceEnvLogLevel), resolver)
s.Require().NoError(err)
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"}
cmd.EnvVars = []string{"STORED_MODE=APP_MODE"}
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 (s *WorkspaceEnvTestSuite) TestDuplicateLiteralTargetRejected() {
cmd := &UpCmd{}
cmd.WorkspaceEnv = []string{"APP_MODE=a", "APP_MODE=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 (s *WorkspaceEnvTestSuite) TestValueMayContainEquals() {
assignment, err := parseWorkspaceEnvAssignment("TOKEN=one=two")
s.Require().NoError(err)
s.Assert().Equal(workspaceEnvAssignment{name: "TOKEN", value: "one=two"}, assignment)
}

func (s *WorkspaceEnvTestSuite) TestOutputHasUniqueTargets() {
base, err := indexWorkspaceEnv([]string{"A=one"})
s.Require().NoError(err)
got, err := composeWorkspaceEnv(base, []resolvedEnvVar{{
assignment: "B=two",
}})
s.Require().NoError(err)
s.Assert().Equal([]string{"A=one", "B=two"}, got)
indexed, err := indexWorkspaceEnv(got)
s.Require().NoError(err)
s.Assert().Len(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)
}
Loading
Loading