26297149101

Committed 22 May 2026 03:37PM UTC coverage: 39.653% (-0.1%) from 39.756%

Build # 26297149101

Build Type

Pull #2132

github

Committed by

web-flow

Commit Message

Merge 70a879ad1 into 6468bfbf2

Pull Request Pull Request #2132: Migrate release process to GitHub Actions with RC support and post-release automation

Coverage Stats

26202 of 66078 relevant lines covered (39.65%)

9.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/airflow/mocks/DockerComposeAPI.go

// Code generated by mockery v2.50.0. DO NOT EDIT.

package mocks

import (
        context "context"

        api "github.com/docker/compose/v2/pkg/api"

        mock "github.com/stretchr/testify/mock"

        types "github.com/compose-spec/compose-go/v2/types"

        volume "github.com/docker/docker/api/types/volume"
)

// DockerComposeAPI is an autogenerated mock type for the DockerComposeAPI type
type DockerComposeAPI struct {
        mock.Mock
}

// Attach provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Attach(ctx context.Context, projectName string, options api.AttachOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Attach")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.AttachOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Build provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Build(ctx context.Context, project *types.Project, options api.BuildOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Build")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.BuildOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Commit provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Commit(ctx context.Context, projectName string, options api.CommitOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Commit")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.CommitOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Copy provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Copy(ctx context.Context, projectName string, options api.CopyOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Copy")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.CopyOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Create provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Create(ctx context.Context, project *types.Project, options api.CreateOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Create")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.CreateOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Down provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Down(ctx context.Context, projectName string, options api.DownOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Down")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.DownOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// DryRunMode provides a mock function with given fields: ctx, dryRun
func (_m *DockerComposeAPI) DryRunMode(ctx context.Context, dryRun bool) (context.Context, error) {
        ret := _m.Called(ctx, dryRun)

        if len(ret) == 0 {
                panic("no return value specified for DryRunMode")
        }

        var r0 context.Context
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, bool) (context.Context, error)); ok {
                return rf(ctx, dryRun)
        }
        if rf, ok := ret.Get(0).(func(context.Context, bool) context.Context); ok {
                r0 = rf(ctx, dryRun)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).(context.Context)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, bool) error); ok {
                r1 = rf(ctx, dryRun)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Events provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Events(ctx context.Context, projectName string, options api.EventsOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Events")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.EventsOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Exec provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Exec(ctx context.Context, projectName string, options api.RunOptions) (int, error) {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Exec")
        }

        var r0 int
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.RunOptions) (int, error)); ok {
                return rf(ctx, projectName, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, api.RunOptions) int); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Get(0).(int)
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, api.RunOptions) error); ok {
                r1 = rf(ctx, projectName, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Export provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Export(ctx context.Context, projectName string, options api.ExportOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Export")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.ExportOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Generate provides a mock function with given fields: ctx, options
func (_m *DockerComposeAPI) Generate(ctx context.Context, options api.GenerateOptions) (*types.Project, error) {
        ret := _m.Called(ctx, options)

        if len(ret) == 0 {
                panic("no return value specified for Generate")
        }

        var r0 *types.Project
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, api.GenerateOptions) (*types.Project, error)); ok {
                return rf(ctx, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, api.GenerateOptions) *types.Project); ok {
                r0 = rf(ctx, options)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).(*types.Project)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, api.GenerateOptions) error); ok {
                r1 = rf(ctx, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Images provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Images(ctx context.Context, projectName string, options api.ImagesOptions) (map[string]api.ImageSummary, error) {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Images")
        }

        var r0 map[string]api.ImageSummary
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.ImagesOptions) (map[string]api.ImageSummary, error)); ok {
                return rf(ctx, projectName, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, api.ImagesOptions) map[string]api.ImageSummary); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).(map[string]api.ImageSummary)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, api.ImagesOptions) error); ok {
                r1 = rf(ctx, projectName, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Kill provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Kill(ctx context.Context, projectName string, options api.KillOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Kill")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.KillOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// List provides a mock function with given fields: ctx, options
func (_m *DockerComposeAPI) List(ctx context.Context, options api.ListOptions) ([]api.Stack, error) {
        ret := _m.Called(ctx, options)

        if len(ret) == 0 {
                panic("no return value specified for List")
        }

        var r0 []api.Stack
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, api.ListOptions) ([]api.Stack, error)); ok {
                return rf(ctx, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, api.ListOptions) []api.Stack); ok {
                r0 = rf(ctx, options)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).([]api.Stack)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, api.ListOptions) error); ok {
                r1 = rf(ctx, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Logs provides a mock function with given fields: ctx, projectName, consumer, options
func (_m *DockerComposeAPI) Logs(ctx context.Context, projectName string, consumer api.LogConsumer, options api.LogOptions) error {
        ret := _m.Called(ctx, projectName, consumer, options)

        if len(ret) == 0 {
                panic("no return value specified for Logs")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.LogConsumer, api.LogOptions) error); ok {
                r0 = rf(ctx, projectName, consumer, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// MaxConcurrency provides a mock function with given fields: parallel
func (_m *DockerComposeAPI) MaxConcurrency(parallel int) {
        _m.Called(parallel)
}

// Pause provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Pause(ctx context.Context, projectName string, options api.PauseOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Pause")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.PauseOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Port provides a mock function with given fields: ctx, projectName, service, port, options
func (_m *DockerComposeAPI) Port(ctx context.Context, projectName string, service string, port uint16, options api.PortOptions) (string, int, error) {
        ret := _m.Called(ctx, projectName, service, port, options)

        if len(ret) == 0 {
                panic("no return value specified for Port")
        }

        var r0 string
        var r1 int
        var r2 error
        if rf, ok := ret.Get(0).(func(context.Context, string, string, uint16, api.PortOptions) (string, int, error)); ok {
                return rf(ctx, projectName, service, port, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, string, uint16, api.PortOptions) string); ok {
                r0 = rf(ctx, projectName, service, port, options)
        } else {
                r0 = ret.Get(0).(string)
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, string, uint16, api.PortOptions) int); ok {
                r1 = rf(ctx, projectName, service, port, options)
        } else {
                r1 = ret.Get(1).(int)
        }

        if rf, ok := ret.Get(2).(func(context.Context, string, string, uint16, api.PortOptions) error); ok {
                r2 = rf(ctx, projectName, service, port, options)
        } else {
                r2 = ret.Error(2)
        }

        return r0, r1, r2
}

// Ps provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Ps(ctx context.Context, projectName string, options api.PsOptions) ([]api.ContainerSummary, error) {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Ps")
        }

        var r0 []api.ContainerSummary
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.PsOptions) ([]api.ContainerSummary, error)); ok {
                return rf(ctx, projectName, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, api.PsOptions) []api.ContainerSummary); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).([]api.ContainerSummary)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, api.PsOptions) error); ok {
                r1 = rf(ctx, projectName, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Publish provides a mock function with given fields: ctx, project, repository, options
func (_m *DockerComposeAPI) Publish(ctx context.Context, project *types.Project, repository string, options api.PublishOptions) error {
        ret := _m.Called(ctx, project, repository, options)

        if len(ret) == 0 {
                panic("no return value specified for Publish")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, string, api.PublishOptions) error); ok {
                r0 = rf(ctx, project, repository, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Pull provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Pull(ctx context.Context, project *types.Project, options api.PullOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Pull")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.PullOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Push provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Push(ctx context.Context, project *types.Project, options api.PushOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Push")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.PushOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Remove provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Remove(ctx context.Context, projectName string, options api.RemoveOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Remove")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.RemoveOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Restart provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Restart(ctx context.Context, projectName string, options api.RestartOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Restart")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.RestartOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// RunOneOffContainer provides a mock function with given fields: ctx, project, opts
func (_m *DockerComposeAPI) RunOneOffContainer(ctx context.Context, project *types.Project, opts api.RunOptions) (int, error) {
        ret := _m.Called(ctx, project, opts)

        if len(ret) == 0 {
                panic("no return value specified for RunOneOffContainer")
        }

        var r0 int
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.RunOptions) (int, error)); ok {
                return rf(ctx, project, opts)
        }
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.RunOptions) int); ok {
                r0 = rf(ctx, project, opts)
        } else {
                r0 = ret.Get(0).(int)
        }

        if rf, ok := ret.Get(1).(func(context.Context, *types.Project, api.RunOptions) error); ok {
                r1 = rf(ctx, project, opts)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Scale provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Scale(ctx context.Context, project *types.Project, options api.ScaleOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Scale")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.ScaleOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Start provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Start(ctx context.Context, projectName string, options api.StartOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Start")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.StartOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Stop provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Stop(ctx context.Context, projectName string, options api.StopOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Stop")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.StopOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Top provides a mock function with given fields: ctx, projectName, services
func (_m *DockerComposeAPI) Top(ctx context.Context, projectName string, services []string) ([]api.ContainerProcSummary, error) {
        ret := _m.Called(ctx, projectName, services)

        if len(ret) == 0 {
                panic("no return value specified for Top")
        }

        var r0 []api.ContainerProcSummary
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, []string) ([]api.ContainerProcSummary, error)); ok {
                return rf(ctx, projectName, services)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, []string) []api.ContainerProcSummary); ok {
                r0 = rf(ctx, projectName, services)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).([]api.ContainerProcSummary)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
                r1 = rf(ctx, projectName, services)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// UnPause provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) UnPause(ctx context.Context, projectName string, options api.PauseOptions) error {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for UnPause")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.PauseOptions) error); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Up provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Up(ctx context.Context, project *types.Project, options api.UpOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Up")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.UpOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// Viz provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Viz(ctx context.Context, project *types.Project, options api.VizOptions) (string, error) {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Viz")
        }

        var r0 string
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.VizOptions) (string, error)); ok {
                return rf(ctx, project, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.VizOptions) string); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Get(0).(string)
        }

        if rf, ok := ret.Get(1).(func(context.Context, *types.Project, api.VizOptions) error); ok {
                r1 = rf(ctx, project, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Volumes provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Volumes(ctx context.Context, project string, options api.VolumesOptions) ([]*volume.Volume, error) {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Volumes")
        }

        var r0 []*volume.Volume
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.VolumesOptions) ([]*volume.Volume, error)); ok {
                return rf(ctx, project, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, api.VolumesOptions) []*volume.Volume); ok {
                r0 = rf(ctx, project, options)
        } else {
                if ret.Get(0) != nil {
                        r0 = ret.Get(0).([]*volume.Volume)
                }
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, api.VolumesOptions) error); ok {
                r1 = rf(ctx, project, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Wait provides a mock function with given fields: ctx, projectName, options
func (_m *DockerComposeAPI) Wait(ctx context.Context, projectName string, options api.WaitOptions) (int64, error) {
        ret := _m.Called(ctx, projectName, options)

        if len(ret) == 0 {
                panic("no return value specified for Wait")
        }

        var r0 int64
        var r1 error
        if rf, ok := ret.Get(0).(func(context.Context, string, api.WaitOptions) (int64, error)); ok {
                return rf(ctx, projectName, options)
        }
        if rf, ok := ret.Get(0).(func(context.Context, string, api.WaitOptions) int64); ok {
                r0 = rf(ctx, projectName, options)
        } else {
                r0 = ret.Get(0).(int64)
        }

        if rf, ok := ret.Get(1).(func(context.Context, string, api.WaitOptions) error); ok {
                r1 = rf(ctx, projectName, options)
        } else {
                r1 = ret.Error(1)
        }

        return r0, r1
}

// Watch provides a mock function with given fields: ctx, project, options
func (_m *DockerComposeAPI) Watch(ctx context.Context, project *types.Project, options api.WatchOptions) error {
        ret := _m.Called(ctx, project, options)

        if len(ret) == 0 {
                panic("no return value specified for Watch")
        }

        var r0 error
        if rf, ok := ret.Get(0).(func(context.Context, *types.Project, api.WatchOptions) error); ok {
                r0 = rf(ctx, project, options)
        } else {
                r0 = ret.Error(0)
        }

        return r0
}

// NewDockerComposeAPI creates a new instance of DockerComposeAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewDockerComposeAPI(t interface {
        mock.TestingT
        Cleanup(func())
}) *DockerComposeAPI {
        mock := &DockerComposeAPI{}
        mock.Mock.Test(t)

        t.Cleanup(func() { mock.AssertExpectations(t) })

        return mock
}

astronomer / astro-cli / 26297149101

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous