feat(up): interactive up runs on a single plan

Interactive up used to create() the project, then start() it: two
daemon snapshots, the second built from the project as the caller gave
it rather than the canonical one the Create phase ran on.

It now prepares one Create+Start plan, like detached up. The Create
phase runs under the "up" progress scope, then the attach/printer/
monitor session is set up exactly as before, and the Start phase is
dispatched last, outside that scope, on a context that survives
Ctrl+C, with the printer as the hook-log listener. A failed Create
phase reaches neither the session nor the Start phase, and a dry run
only ever runs the Create phase.

The monitor's starting point is the daemon's time, which is read right
before the Start phase: a daemon that answers with a time that can't be
used fails the up with an explicit error, with no container started. One
that can't be asked at all (a read-only socket proxy without the info
endpoint) doesn't: the monitor then follows live events, with a warning.

The session, the watcher and the teardown now use the plan's own
project, which carries what preparation resolved. That makes
use_api_socket work in a foreground up: its config file lives only in
that project. A scenario locks it.

Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>
This commit is contained in:
Nicolas De Loof 2026-10-08 13:11:43 +02:00 • committed by Nicolas De loof
parent e0bbd29843
commit 8011e8a921
8 changed files with 466 additions and 20 deletions

View file

@ -518,6 +518,8 @@ type fakeEventLog struct {
entries []loggedEvent
// since records the Since of every subscription, in order
since []string
// subscribers receive the events emitted after they subscribed
subscribers []chan events.Message
// skew is how far the engine's clock is ahead of the local one
skew time.Duration
@ -566,17 +568,22 @@ func (l *fakeEventLog) emit(msg events.Message) {
now := l.now()
msg.TimeNano = now.UnixNano()
l.entries = append(l.entries, loggedEvent{at: now, msg: msg})
for _, sub := range l.subscribers {
sub <- msg
}
}
// subscribe opens a stream replaying the buffered events newer than
// opts.Since (none when it is empty), followed by the given live events.
// opts.Since (none when it is empty), followed by the given live events, then
// by whatever is emitted from now on.
func (l *fakeEventLog) subscribe(t *testing.T, opts client.EventsListOptions, live ...events.Message) client.EventsResult {
t.Helper()
l.mu.Lock()
defer l.mu.Unlock()
l.since = append(l.since, opts.Since)
messages := make(chan events.Message, len(l.entries)+len(live))
messages := make(chan events.Message, len(l.entries)+len(live)+64)
l.subscribers = append(l.subscribers, messages)
if opts.Since != "" {
since := parseEventsSince(t, opts.Since)
for _, e := range l.entries {

View file

@ -315,7 +315,7 @@ func (s *composeService) startDependencies(ctx context.Context, project *types.P
if len(project.Services) > 0 {
return s.start(ctx, project.Name, api.StartOptions{
Project: project,
}, nil)
})
}
return nil
}

View file

@ -29,7 +29,7 @@ import (
func (s *composeService) Start(ctx context.Context, projectName string, options api.StartOptions) error {
return Run(ctx, func(ctx context.Context) error {
return s.start(ctx, strings.ToLower(projectName), options, nil)
return s.start(ctx, strings.ToLower(projectName), options)
}, "start", s.events)
}
@ -39,12 +39,10 @@ func (s *composeService) Start(ctx context.Context, projectName string, options
// other lifecycle command already uses. ScopeStart's planStartPhase works
// straight off the observed containers (see TestPlanStart_StartOnlyScope) --
// it never converges anything, matching start()'s own historical contract of
// starting what exists, never creating. listener is non-nil only when called
// from interactive up's own start phase (today's create()-then-start()
// sequence, unchanged by this PR -- see upDetached's doc comment): it streams
// pre_start/post_start hook logs into the attached session, exactly what
// newPlanExecutor's listener parameter exists for.
func (s *composeService) start(ctx context.Context, projectName string, options api.StartOptions, listener api.ContainerEventListener) error {
// starting what exists, never creating. Interactive up does not go through
// here: it drives its own plan's Start phase (see runInteractiveUp), so there
// is no attached session for the hook logs to stream into.
func (s *composeService) start(ctx context.Context, projectName string, options api.StartOptions) error {
project := options.Project
if project == nil {
containers, err := s.getContainers(ctx, projectName, oneOffExclude, true)
@ -88,7 +86,7 @@ func (s *composeService) start(ctx context.Context, projectName string, options
// combination nothing rejects). exec.waitTimeout reproduces that for the
// plan's own OpWaitCondition nodes, each with its own fresh window
// starting when that wait begins -- see upDetached's identical reasoning.
exec := s.newPlanExecutor(project, observed, listener)
exec := s.newPlanExecutor(project, observed, nil)
exec.waitTimeout = options.WaitTimeout
if err := exec.run(ctx, plan); err != nil {

View file

@ -144,7 +144,7 @@ func TestStart_NoOpStartIsSilentAndOnlyListsContainers(t *testing.T) {
stoppedServiceContainer("web", 1, container.StateRunning),
}}, nil)
err := svc.start(t.Context(), "prj", api.StartOptions{Project: project}, nil)
err := svc.start(t.Context(), "prj", api.StartOptions{Project: project})
assert.NilError(t, err)
assert.Equal(t, len(rec.summary()), 0, "a no-op start must be silent: %v", rec.summary())
}
@ -184,7 +184,7 @@ func TestStart_WaitTimeoutBoundsDependencyWaits(t *testing.T) {
// failure instead of a hang
ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
defer cancel()
err := svc.start(ctx, "prj", api.StartOptions{Project: project, WaitTimeout: 200 * time.Millisecond}, nil)
err := svc.start(ctx, "prj", api.StartOptions{Project: project, WaitTimeout: 200 * time.Millisecond})
assert.Error(t, err, "timeout waiting for dependencies")
}

View file

@ -44,11 +44,14 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options
if err := options.Validate(); err != nil {
return err
}
var created *createdUp
err := Run(ctx, tracing.SpanWrapFunc("project/up", tracing.ProjectOptions(ctx, project), func(ctx context.Context) error {
if options.Start.Attach == nil {
return s.upDetached(ctx, project, options)
}
return s.create(ctx, project, options.Create)
var err error
created, err = s.upCreatePhase(ctx, project, options)
return err
}), "up", s.events)
if err != nil {
return err
@ -61,16 +64,52 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options
_, _ = fmt.Fprintln(s.stdout(), "end of 'compose up' output, interactive run is not supported in dry-run mode")
return err
}
return s.runInteractiveUp(ctx, project, options)
return s.runInteractiveUp(ctx, created, options)
}
// createdUp is what an interactive up carries from its Create phase to its
// Start phase: the canonical project the plan was built for, and the plan run
// whose Start phase is still to dispatch. Both phases share the one daemon
// snapshot and the one plan the Create phase was prepared from.
type createdUp struct {
project *types.Project
run *planRun
}
// upCreatePhase prepares interactive up's single Create+Start plan and runs
// its Create phase only, under the "up" progress scope the caller wraps it in.
// The Start phase is deliberately left out of that scope: it runs once
// runInteractiveUp has set up the session streaming logs to the terminal, and
// the progress display's refresh would repaint over them.
func (s *composeService) upCreatePhase(ctx context.Context, project *types.Project, options api.UpOptions) (*createdUp, error) {
project, observed, plan, err := s.preparePlan(ctx, project, options.Create, ScopeCreateStart)
if err != nil {
return nil, err
}
// Must run against the pre-execution snapshot, see upDetached.
emitRunningEvents(project, observed, plan, s.events)
// Same per-wait --wait-timeout window as upDetached, see there.
exec := s.newPlanExecutor(project, observed, nil)
exec.waitTimeout = options.Start.WaitTimeout
run, err := exec.begin(plan)
if err != nil {
return nil, err
}
if err := run.runCreate(ctx); err != nil {
return nil, err
}
return &createdUp{project: project, run: run}, nil
}
// upDetached runs detached `up`'s Create and Start phases as a single plan:
// the semantic switchover from create() + start() -- two separate daemon
// snapshots, the second blind to what the first just did -- to one
// preparePlan/executePlan pass covering both phases (epic #14081, lot 2).
// Interactive up keeps the create()+start() sequence for now: its own
// create/start phase boundary (attach/printer/monitor setup in between) is a
// separate, riskier item of the same lot.
// Interactive up prepares the same plan but drives its two phases itself,
// with the attach/printer/monitor setup in between (see upCreatePhase).
func (s *composeService) upDetached(ctx context.Context, project *types.Project, options api.UpOptions) error {
project, observed, plan, err := s.preparePlan(ctx, project, options.Create, ScopeCreateStart)
if err != nil {
@ -181,7 +220,15 @@ type upSession struct {
exitCode int
}
func (s *composeService) runInteractiveUp(ctx context.Context, project *types.Project, options api.UpOptions) error {
// runInteractiveUp sets up the attach/printer/monitor session around the
// Start phase of created's plan, runs it, then follows the application until
// it terminates. The Create phase already ran, and signal.Notify only comes
// after it: Ctrl+C during Create keeps its default behavior.
func (s *composeService) runInteractiveUp(ctx context.Context, created *createdUp, options api.UpOptions) error {
// the plan's own project, not the caller's: the one carrying what
// preparePlan resolved (see useAPISocket)
project := created.project
// if we get a second signal during shutdown, we kill the services
// immediately, so the channel needs to have sufficient capacity or
// we might miss a signal while setting up the second channel read
@ -283,6 +330,17 @@ func (s *composeService) runInteractiveUp(ctx context.Context, project *types.Pr
}
monitor.withListener(u.followStartedContainers(attached))
// The monitor replays events from the daemon's time. Read it now, before
// the Start phase: the point precedes the first start, and a daemon that
// answers with a time that can't be used fails the command without any
// container started. A daemon that can't be asked doesn't (see
// readDaemonTime): the monitor then follows live events.
if err := monitor.readDaemonTime(globalCtx); err != nil {
cancel()
_ = u.eg.Wait()
return err
}
u.eg.Go(func() error {
err := monitor.Start(globalCtx)
// The monitor returning means every watched container is gone for
@ -310,7 +368,8 @@ func (s *composeService) runInteractiveUp(ctx context.Context, project *types.Pr
})
// We use the parent context without cancellation as we manage sigterm to stop the stack
err = s.start(context.WithoutCancel(ctx), project.Name, options.Start, u.printer.HandleEvent)
err = created.run.runStart(context.WithoutCancel(ctx), u.printer.HandleEvent)
err = translateWaitTimeout(err)
if err != nil && !u.isTerminated.Load() { // Ignore error if the process is terminated
cancel()
_ = u.eg.Wait()

View file

@ -0,0 +1,363 @@
//go:build !windows
/*
Copyright 2026 Docker Compose CLI authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compose
import (
"bytes"
"context"
"errors"
"io"
"strings"
"sync"
"testing"
"time"
"github.com/compose-spec/compose-go/v2/types"
"github.com/docker/cli/cli/config/configfile"
"github.com/docker/cli/cli/streams"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/events"
"github.com/moby/moby/api/types/image"
"github.com/moby/moby/client"
"go.uber.org/mock/gomock"
"gotest.tools/v3/assert"
"github.com/docker/compose/v5/pkg/api"
"github.com/docker/compose/v5/pkg/mocks"
)
// containerExitDelay is how long after its start the test container exits
const containerExitDelay = 100 * time.Millisecond
// interactiveUpDaemon is the engine as an interactive `up` of a one-service
// project sees it: it records the order of the calls that matter, and
// reproduces the engine's event log (see fakeEventLog) so a container that
// exits as soon as it starts is observable whenever the monitor subscribes.
type interactiveUpDaemon struct {
mu sync.Mutex
calls []string
created bool
eventLog *fakeEventLog
// createErr, when set, fails ContainerCreate
createErr error
// slowSubscription delays the completion of the events subscription well
// past the moment the container has started and exited
slowSubscription bool
started chan struct{}
startedOnce sync.Once
}
func (d *interactiveUpDaemon) record(call string) {
d.mu.Lock()
defer d.mu.Unlock()
d.calls = append(d.calls, call)
}
func (d *interactiveUpDaemon) recorded() []string {
d.mu.Lock()
defer d.mu.Unlock()
return append([]string(nil), d.calls...)
}
func (d *interactiveUpDaemon) indexOf(call string) int {
for i, c := range d.recorded() {
if c == call {
return i
}
}
return -1
}
func expectInteractiveUpDaemon(t *testing.T, apiClient *mocks.MockAPIClient) *interactiveUpDaemon {
t.Helper()
d := &interactiveUpDaemon{eventLog: &fakeEventLog{}, started: make(chan struct{})}
labels := map[string]string{
api.ProjectLabel: "test",
api.ServiceLabel: "web",
api.OneoffLabel: "False",
api.ContainerNumberLabel: "1",
api.ConfigHashLabel: "hash",
}
apiClient.EXPECT().ImageInspect(gomock.Any(), "alpine", gomock.Any()).AnyTimes().
Return(client.ImageInspectResult{InspectResponse: image.InspectResponse{ID: "sha256:alpine"}}, nil)
apiClient.EXPECT().NetworkList(gomock.Any(), gomock.Any()).AnyTimes().Return(client.NetworkListResult{}, nil)
apiClient.EXPECT().VolumeList(gomock.Any(), gomock.Any()).AnyTimes().Return(client.VolumeListResult{}, nil)
apiClient.EXPECT().ContainerList(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(context.Context, client.ContainerListOptions) (client.ContainerListResult, error) {
d.mu.Lock()
defer d.mu.Unlock()
if !d.created {
return client.ContainerListResult{}, nil
}
return client.ContainerListResult{Items: []container.Summary{{
ID: "c1", Names: []string{"/test-web-1"}, Labels: labels, State: container.StateCreated,
}}}, nil
})
apiClient.EXPECT().ContainerCreate(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(context.Context, client.ContainerCreateOptions) (client.ContainerCreateResult, error) {
d.record("create")
if d.createErr != nil {
return client.ContainerCreateResult{}, d.createErr
}
d.mu.Lock()
d.created = true
d.mu.Unlock()
return client.ContainerCreateResult{ID: "c1"}, nil
})
apiClient.EXPECT().ContainerInspect(gomock.Any(), "c1", gomock.Any()).AnyTimes().
Return(client.ContainerInspectResult{Container: container.InspectResponse{
ID: "c1",
Name: "/test-web-1",
Config: &container.Config{Labels: labels},
State: &container.State{Status: container.StateExited},
NetworkSettings: &container.NetworkSettings{},
}}, nil)
// no attach endpoint: the log stream falls back to the logs API, which
// the monitor-less assertions below don't read
apiClient.EXPECT().ContainerAttach(gomock.Any(), "c1", gomock.Any()).AnyTimes().
DoAndReturn(func(context.Context, string, client.ContainerAttachOptions) (client.ContainerAttachResult, error) {
d.record("attach")
return client.ContainerAttachResult{}, errors.New("attach not supported")
})
apiClient.EXPECT().ContainerLogs(gomock.Any(), "c1", gomock.Any()).AnyTimes().
Return(io.NopCloser(strings.NewReader("")), nil)
// the monitor reads the daemon's time to know from when to ask for events
apiClient.EXPECT().Info(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(context.Context, client.InfoOptions) (client.SystemInfoResult, error) {
return d.eventLog.info()
})
apiClient.EXPECT().Events(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(_ context.Context, opts client.EventsListOptions) client.EventsResult {
d.record("events")
if d.slowSubscription {
select {
case <-d.started:
time.Sleep(containerExitDelay + 200*time.Millisecond)
case <-time.After(5 * time.Second):
}
}
return d.eventLog.subscribe(t, opts)
})
// a teardown (the test giving up on a hung up) must not trip the mock
apiClient.EXPECT().ContainerStop(gomock.Any(), "c1", gomock.Any()).AnyTimes().Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().ContainerKill(gomock.Any(), "c1", gomock.Any()).AnyTimes().Return(client.ContainerKillResult{}, nil)
// the container exits right after it starts
apiClient.EXPECT().ContainerStart(gomock.Any(), "c1", gomock.Any()).AnyTimes().
DoAndReturn(func(context.Context, string, client.ContainerStartOptions) (client.ContainerStartResult, error) {
d.record("start")
defer d.startedOnce.Do(func() { close(d.started) })
d.eventLog.emit(containerMessage(events.ActionStart, "c1", "test-web-1", "web", labels))
// The engine reports the exit some time after the start call, not
// within it: long enough here for the monitor, launched just
// before the Start phase, to have taken its timestamp.
timer := time.AfterFunc(containerExitDelay, func() {
d.eventLog.emit(containerMessage(events.ActionDie, "c1", "test-web-1", "web", map[string]string{"exitCode": "0"}))
})
t.Cleanup(func() { timer.Stop() })
return client.ContainerStartResult{}, nil
})
return d
}
// progressRecorder records the lifetime of the progress scopes ("up") in the
// daemon's call log, to order them against the engine calls.
type progressRecorder struct{ d *interactiveUpDaemon }
func (p progressRecorder) Start(_ context.Context, operation string) {
p.d.record("progress-start:" + operation)
}
func (p progressRecorder) Done(operation string, _ bool) { p.d.record("progress-done:" + operation) }
func (p progressRecorder) On(...api.Resource) {}
// interactiveUpHarness is a compose service wired to the interactiveUpDaemon.
type interactiveUpHarness struct {
svc *composeService
daemon *interactiveUpDaemon
out *bytes.Buffer
}
func newInteractiveUpHarness(t *testing.T) *interactiveUpHarness {
t.Helper()
mockCtrl := gomock.NewController(t)
cli := mocks.NewMockCli(mockCtrl)
apiClient := mocks.NewMockAPIClient(mockCtrl)
out := &bytes.Buffer{}
cli.EXPECT().Client().Return(apiClient).AnyTimes()
cli.EXPECT().ConfigFile().Return(&configfile.ConfigFile{}).AnyTimes()
cli.EXPECT().Out().Return(streams.NewOut(out)).AnyTimes()
cli.EXPECT().Err().Return(streams.NewOut(io.Discard)).AnyTimes()
apiClient.EXPECT().DaemonHost().Return("unix:///var/run/docker.sock").AnyTimes()
apiClient.EXPECT().Ping(gomock.Any(), client.PingOptions{NegotiateAPIVersion: true}).
Return(client.PingResult{APIVersion: "1.44"}, nil).AnyTimes()
apiClient.EXPECT().ClientVersion().Return("1.44").AnyTimes()
daemon := expectInteractiveUpDaemon(t, apiClient)
svc, err := NewComposeService(cli, WithEventProcessor(progressRecorder{daemon}))
assert.NilError(t, err)
return &interactiveUpHarness{svc: svc.(*composeService), daemon: daemon, out: out}
}
func interactiveUpProject() *types.Project {
return &types.Project{
Name: "test",
Services: types.Services{"web": {Name: "web", ContainerSpec: types.ContainerSpec{Image: "alpine"}}},
Networks: types.Networks{},
Volumes: types.Volumes{},
}
}
func interactiveUpOptions() api.UpOptions {
return api.UpOptions{Start: api.StartOptions{Attach: &testLogConsumer{}, AttachTo: []string{"web"}}}
}
// up runs Up, failing the test instead of hanging when it doesn't return.
func (h *interactiveUpHarness) up(t *testing.T) error {
t.Helper()
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
done := make(chan error, 1)
go func() { done <- h.svc.Up(ctx, interactiveUpProject(), interactiveUpOptions()) }()
select {
case err := <-done:
return err
case <-time.After(10 * time.Second):
cancel()
select {
case <-done:
case <-time.After(5 * time.Second):
}
t.Fatalf("up did not return; calls so far: %v", h.daemon.recorded())
return nil
}
}
// TestUpInteractivePhaseOrder pins the sequence of an interactive up: the
// Create phase runs under the "up" progress scope and completes, the session
// then attaches to the created container, and only then is the Start phase
// dispatched, outside that scope (whose refresh would repaint over the logs).
func TestUpInteractivePhaseOrder(t *testing.T) {
h := newInteractiveUpHarness(t)
assert.NilError(t, h.up(t))
d := h.daemon
create, done, attach, start := d.indexOf("create"), d.indexOf("progress-done:up"), d.indexOf("attach"), d.indexOf("start")
assert.Assert(t, create >= 0 && done >= 0 && attach >= 0 && start >= 0, "calls: %v", d.recorded())
assert.Assert(t, create < done, "the container is created within the up progress scope: %v", d.recorded())
assert.Assert(t, done < attach, "the session attaches once the up progress scope is over: %v", d.recorded())
assert.Assert(t, attach < start, "no container starts before the session is attached: %v", d.recorded())
}
// TestUpInteractiveSeesContainerExitingBeforeSubscription is the monitor's
// startup race seen from interactive up: the Start phase runs right after the
// monitor is launched, so the container may start and exit before the event
// subscription is effective (modeled here as the subscription only completing
// once the container has started). The exit must still be observed, or up
// would wait on the container forever. The replay starts at the daemon's time,
// read before the container listing: the daemon's clock is set here well apart
// from the client's, as it is for a remote daemon, so that the events it
// stamps are only replayed when asked for from its own time.
func TestUpInteractiveSeesContainerExitingBeforeSubscription(t *testing.T) {
h := newInteractiveUpHarness(t)
h.daemon.slowSubscription = true
h.daemon.eventLog.skew = -time.Hour
assert.NilError(t, h.up(t))
log := h.daemon.eventLog
assert.Equal(t, len(log.since), 1)
assert.Assert(t, log.since[0] != "", "the events subscription must replay what preceded it")
reported, err := time.Parse(time.RFC3339Nano, log.reportedTime)
assert.NilError(t, err)
assert.Assert(t, parseEventsSince(t, log.since[0]).Equal(reported),
"since %s is not the daemon time %s", log.since[0], log.reportedTime)
}
// TestUpInteractiveFailsWithoutDaemonTime: the monitor replays events from the
// daemon's time, and a daemon that answers with a time that can't be used fails
// the up, with that explicit error, before the Start phase: no container is
// started, and no event subscription was ever opened.
func TestUpInteractiveFailsWithoutDaemonTime(t *testing.T) {
tests := []struct {
name string
setup func(*fakeEventLog)
}{
{name: "system time is empty", setup: func(log *fakeEventLog) { log.setSystemTime("") }},
{name: "system time is not a time", setup: func(log *fakeEventLog) { log.setSystemTime("yesterday-ish") }},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
h := newInteractiveUpHarness(t)
tt.setup(h.daemon.eventLog)
err := h.up(t)
assert.ErrorContains(t, err, "reading the daemon time to subscribe to container events")
calls := h.daemon.recorded()
assert.Assert(t, h.daemon.indexOf("create") >= 0, "the Create phase ran: %v", calls)
assert.Equal(t, h.daemon.indexOf("start"), -1, "no container is started: %v", calls)
assert.Equal(t, h.daemon.indexOf("events"), -1, "no event subscription is opened: %v", calls)
})
}
}
// TestUpInteractiveWithoutInfoStillStarts: a daemon that can't be asked for its
// time (a read-only socket proxy that doesn't expose the info endpoint) doesn't
// fail the up, which worked without it: the containers start, and the monitor
// subscribes to live events, with no starting point.
func TestUpInteractiveWithoutInfoStillStarts(t *testing.T) {
h := newInteractiveUpHarness(t)
h.daemon.eventLog.infoErr = errors.New("403 Forbidden")
assert.NilError(t, h.up(t))
assert.Assert(t, h.daemon.indexOf("start") >= 0, "the Start phase ran: %v", h.daemon.recorded())
assert.DeepEqual(t, h.daemon.eventLog.since, []string{""})
}
// TestUpInteractiveFailedCreateStopsThere: a Create phase that fails reaches
// neither the attach session nor the Start phase.
func TestUpInteractiveFailedCreateStopsThere(t *testing.T) {
h := newInteractiveUpHarness(t)
h.daemon.createErr = errors.New("no space left on device")
err := h.up(t)
assert.ErrorContains(t, err, "no space left on device")
assert.DeepEqual(t, h.daemon.recorded(), []string{"progress-start:up", "create", "progress-done:up"})
}
// TestUpInteractiveDryRunOnlyCreates: a dry-run interactive up plans the
// Create phase and never gets to the session or the Start phase.
func TestUpInteractiveDryRunOnlyCreates(t *testing.T) {
h := newInteractiveUpHarness(t)
h.svc.dryRun = true
assert.NilError(t, h.up(t))
assert.DeepEqual(t, h.daemon.recorded(), []string{"progress-start:up", "create", "progress-done:up"})
assert.Assert(t, strings.Contains(h.out.String(), "interactive run is not supported in dry-run mode"), "output: %q", h.out.String())
}

View file

@ -0,0 +1,6 @@
services:
app:
image: alpine
use_api_socket: true
command: >
sh -c 'if [ -f /run/secrets/docker/config.json ]; then echo apisocket-config-present; else echo apisocket-config-absent; fi'

View file

@ -94,6 +94,19 @@ func TestUpInteractiveDependencyTimeout(t *testing.T) {
ServiceState("web", "created"))
}
// use_api_socket is applied by rewriting the project (a #apisocket config the
// service mounts at /run/secrets/docker/config.json): a foreground up must
// start the containers from that same rewritten project, as a detached one
// does. The file is injected whether or not any credential is configured.
func TestUpInteractiveInjectsAPISocketConfig(t *testing.T) {
NewScenario(t, "a foreground up must give a use_api_socket service its docker config file, as a detached up does").
Step("the service finds the config file in its session output",
ComposeCmd("up", "--menu=false").Within(60*time.Second),
StdoutContains("apisocket-config-present"),
OutputNotContains("apisocket-config-absent"),
ServiceState("app", "exited"))
}
func TestUpInteractiveDryRun(t *testing.T) {
// the progress lines name the container after the project
s := NewScenario(t, "a foreground up --dry-run must report the container creation, never start it and leave nothing behind")