chore: improve error wrapping (#2720)

Improve error wrapping to help detect failures in compose and wait tests.

Author: stevenh

docker.go

@@ -508,12 +508,12 @@ func (c *DockerContainer) Exec(ctx context.Context, cmd []string, options ...tce
 
 response, err := cli.ContainerExecCreate(ctx, c.ID, processOptions.ExecConfig)
 if err != nil {
-return 0, nil, err
+return 0, nil, fmt.Errorf("container exec create: %w", err)
 }
 
 hijack, err := cli.ContainerExecAttach(ctx, response.ID, container.ExecAttachOptions{})
 if err != nil {
-return 0, nil, err
+return 0, nil, fmt.Errorf("container exec attach: %w", err)
 }
 
 processOptions.Reader = hijack.Reader
@@ -528,7 +528,7 @@ func (c *DockerContainer) Exec(ctx context.Context, cmd []string, options ...tce
 for {
 execResp, err := cli.ContainerExecInspect(ctx, response.ID)
 if err != nil {
-return 0, nil, err
+return 0, nil, fmt.Errorf("container exec inspect: %w", err)
 }
 
 if !execResp.Running {
@@ -1129,7 +1129,7 @@ func (p *DockerProvider) CreateContainer(ctx context.Context, req ContainerReque
 
 resp, err := p.client.ContainerCreate(ctx, dockerInput, hostConfig, networkingConfig, platform, req.Name)
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("container create: %w", err)
 }
 
 // #248: If there is more than one network specified in the request attach newly created container to them one by one
@@ -1144,7 +1144,7 @@ func (p *DockerProvider) CreateContainer(ctx context.Context, req ContainerReque
 }
 err = p.client.NetworkConnect(ctx, nw.ID, resp.ID, &endpointSetting)
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("network connect: %w", err)
 }
 }
 }
@@ -1245,7 +1245,7 @@ func (p *DockerProvider) ReuseOrCreateContainer(ctx context.Context, req Contain
 if !p.config.RyukDisabled {
 r, err := reuseOrCreateReaper(context.WithValue(ctx, core.DockerHostContextKey, p.host), sessionID, p)
 if err != nil {
-return nil, fmt.Errorf("%w: creating reaper failed", err)
+return nil, fmt.Errorf("reaper: %w", err)
 }
 termSignal, err = r.Connect()
 if err != nil {

generic.go

@@ -57,7 +57,7 @@ func GenericContainer(ctx context.Context, req GenericContainerRequest) (Contain
 }
 provider, err := req.ProviderType.GetProvider(WithLogger(logging))
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("get provider: %w", err)
 }
 defer provider.Close()
 
@@ -79,7 +79,7 @@ func GenericContainer(ctx context.Context, req GenericContainerRequest) (Contain
 
 if req.Started && !c.IsRunning() {
 if err := c.Start(ctx); err != nil {
-return c, fmt.Errorf("failed to start container: %w", err)
+return c, fmt.Errorf("start container: %w", err)
 }
 }
 return c, nil

modules/compose/compose.go

@@ -129,7 +129,7 @@ func NewDockerComposeWith(opts ...ComposeStackOption) (*dockerCompose, error) {
 
 for i := range opts {
 if err := opts[i].applyToComposeStack(&composeOptions); err != nil {
-return nil, err
+return nil, fmt.Errorf("apply compose stack option: %w", err)
 }
 }
 
@@ -139,11 +139,11 @@ func NewDockerComposeWith(opts ...ComposeStackOption) (*dockerCompose, error) {
 
 dockerCli, err := command.NewDockerCli()
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("new docker client: %w", err)
 }
 
 if err = dockerCli.Initialize(flags.NewClientOptions(), command.WithInitializeClient(makeClient)); err != nil {
-return nil, err
+return nil, fmt.Errorf("initialize docker client: %w", err)
 }
 
 reaperProvider, err := testcontainers.NewDockerProvider()

modules/compose/compose_api.go

@@ -120,19 +120,19 @@ func (r ComposeStackReaders) applyToComposeStack(o *composeStackOptions) error {
 tmp = filepath.Join(tmp, strconv.FormatInt(time.Now().UnixNano(), 10))
 err := os.MkdirAll(tmp, 0o755)
 if err != nil {
-return fmt.Errorf("failed to create temporary directory: %w", err)
+return fmt.Errorf("create temporary directory: %w", err)
 }
 
 name := fmt.Sprintf(baseName, i)
 
 bs, err := io.ReadAll(reader)
 if err != nil {
-return fmt.Errorf("failed to read from reader: %w", err)
+return fmt.Errorf("read from reader: %w", err)
 }
 
 err = os.WriteFile(filepath.Join(tmp, name), bs, 0o644)
 if err != nil {
-return fmt.Errorf("failed to write to temporary file: %w", err)
+return fmt.Errorf("write to temporary file: %w", err)
 }
 
 f[i] = filepath.Join(tmp, name)
@@ -311,7 +311,7 @@ func (d *dockerCompose) Up(ctx context.Context, opts ...StackUpOption) error {
 },
 })
 if err != nil {
-return err
+return fmt.Errorf("compose up: %w", err)
 }
 
 err = d.lookupNetworks(ctx)
@@ -442,7 +442,7 @@ func (d *dockerCompose) lookupContainer(ctx context.Context, svcName string) (*t
 ),
 })
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("container list: %w", err)
 }
 
 if len(containers) == 0 {
@@ -458,7 +458,7 @@ func (d *dockerCompose) lookupContainer(ctx context.Context, svcName string) (*t
 
 dockerProvider, err := testcontainers.NewDockerProvider(testcontainers.WithLogger(d.logger))
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("new docker provider: %w", err)
 }
 
 dockerProvider.SetClient(d.dockerClient)
@@ -479,7 +479,7 @@ func (d *dockerCompose) lookupNetworks(ctx context.Context) error {
 ),
 })
 if err != nil {
-return err
+return fmt.Errorf("network list: %w", err)
 }
 
 for _, n := range networks {
@@ -504,12 +504,12 @@ func (d *dockerCompose) compileProject(ctx context.Context) (*types.Project, err
 
 compiledOptions, err := cli.NewProjectOptions(d.configs, projectOptions...)
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("new project options: %w", err)
 }
 
 proj, err := compiledOptions.LoadProject(ctx)
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("load project: %w", err)
 }
 
 for i, s := range proj.Services {
@@ -568,7 +568,7 @@ func withEnv(env map[string]string) func(*cli.ProjectOptions) error {
 func makeClient(*command.DockerCli) (client.APIClient, error) {
 dockerClient, err := testcontainers.NewDockerClientWithOpts(context.Background())
 if err != nil {
-return nil, err
+return nil, fmt.Errorf("new docker client: %w", err)
 }
 return dockerClient, nil
 }

modules/compose/compose_local.go

@@ -136,7 +136,7 @@ func (dc *LocalDockerCompose) containerNameFromServiceName(service, separator st
 func (dc *LocalDockerCompose) applyStrategyToRunningContainer() error {
 cli, err := testcontainers.NewDockerClientWithOpts(context.Background())
 if err != nil {
-return err
+return fmt.Errorf("new docker client: %w", err)
 }
 defer cli.Close()
 
@@ -150,22 +150,22 @@ func (dc *LocalDockerCompose) applyStrategyToRunningContainer() error {
 containerListOptions := container.ListOptions{Filters: f, All: true}
 containers, err := cli.ContainerList(context.Background(), containerListOptions)
 if err != nil {
-return fmt.Errorf("error %w occurred while filtering the service %s: %d by name and published port", err, k.service, k.publishedPort)
+return fmt.Errorf("container list service %q: %w", k.service, err)
 }
 
 if len(containers) == 0 {
-return fmt.Errorf("service with name %s not found in list of running containers", k.service)
+return fmt.Errorf("service with name %q not found in list of running containers", k.service)
 }
 
 // The length should always be a list of 1, since we are matching one service name at a time
 if l := len(containers); l > 1 {
-return fmt.Errorf("expecting only one running container for %s but got %d", k.service, l)
+return fmt.Errorf("expecting only one running container for %q but got %d", k.service, l)
 }
 container := containers[0]
 strategy := dc.WaitStrategyMap[k]
 dockerProvider, err := testcontainers.NewDockerProvider(testcontainers.WithLogger(dc.Logger))
 if err != nil {
-return fmt.Errorf("unable to create new Docker Provider: %w", err)
+return fmt.Errorf("new docker provider: %w", err)
 }
 defer dockerProvider.Close()
 
@@ -175,7 +175,7 @@ func (dc *LocalDockerCompose) applyStrategyToRunningContainer() error {
 
 err = strategy.WaitUntilReady(context.Background(), dockercontainer)
 if err != nil {
-return fmt.Errorf("unable to apply wait strategy %v to service %s due to %w", strategy, k.service, err)
+return fmt.Errorf("wait until ready %v to service %q due: %w", strategy, k.service, err)
 }
 }
 return nil
@@ -223,7 +223,6 @@ func (dc *LocalDockerCompose) WithExposedService(service string, port int, strat
 // depending on the version services names are composed in a different way
 func (dc *LocalDockerCompose) determineVersion() error {
 execErr := executeCompose(dc, []string{"version", "--short"})
-
 if err := execErr.Error; err != nil {
 return err
 }
@@ -235,7 +234,7 @@ func (dc *LocalDockerCompose) determineVersion() error {
 
 majorVersion, err := strconv.ParseInt(string(components[0]), 10, 8)
 if err != nil {
-return err
+return fmt.Errorf("parsing major version: %w", err)
 }
 
 switch majorVersion {
@@ -263,11 +262,11 @@ func (dc *LocalDockerCompose) validate() error {
 
 yamlFile, err := os.ReadFile(abs)
 if err != nil {
-return err
+return fmt.Errorf("read compose file %q: %w", abs, err)
 }
 err = yaml.Unmarshal(yamlFile, &c)
 if err != nil {
-return err
+return fmt.Errorf("unmarshalling file %q: %w", abs, err)
 }
 
 if dc.Services == nil {
@@ -448,7 +447,9 @@ func (w *capturingPassThroughWriter) Bytes() []byte {
 
 // Which checks if a binary is present in PATH
 func which(binary string) error {
-_, err := exec.LookPath(binary)
+if _, err := exec.LookPath(binary); err != nil {
+return fmt.Errorf("lookup: %w", err)
+}
 
-return err
+return nil
 }