chore!: export DockerCompose type in compose package (testcontainers#2953)

* chore!: rename (deprecated) interface to prevent name collision

BREAKING CHANGE: rename DockerCompose interface to DockerComposer to prevent a
naming collision when exporting DockerCompose type

* chore: rename DockerCompose to make it exported

* docs: update message because of changing interface name

* chore: use ComposeStack interface instead in unit test

---------

Co-authored-by: Manuel de la Peña <[email protected]>
Co-authored-by: Steven Hartland <[email protected]>

Author: 3 people

modules/compose/compose.go

@@ -78,16 +78,16 @@ type ComposeStack interface {
 	ServiceContainer(ctx context.Context, svcName string) (*testcontainers.DockerContainer, error)
 }
 
-// Deprecated: DockerCompose is the old shell escape based API
+// Deprecated: DockerComposer is the old shell escape based API
 // use ComposeStack instead
-// DockerCompose defines the contract for running Docker Compose
-type DockerCompose interface {
+// DockerComposer defines the contract for running Docker Compose
+type DockerComposer interface {
 	Down() ExecError
 	Invoke() ExecError
-	WaitForService(string, wait.Strategy) DockerCompose
-	WithCommand([]string) DockerCompose
-	WithEnv(map[string]string) DockerCompose
-	WithExposedService(string, int, wait.Strategy) DockerCompose
+	WaitForService(string, wait.Strategy) DockerComposer
+	WithCommand([]string) DockerComposer
+	WithEnv(map[string]string) DockerComposer
+	WithExposedService(string, int, wait.Strategy) DockerComposer
 }
 
 type waitService struct {
@@ -123,11 +123,11 @@ func WithProfiles(profiles ...string) ComposeStackOption {
 	return ComposeProfiles(profiles)
 }
 
-func NewDockerCompose(filePaths ...string) (*dockerCompose, error) {
+func NewDockerCompose(filePaths ...string) (*DockerCompose, error) {
 	return NewDockerComposeWith(WithStackFiles(filePaths...))
 }
 
-func NewDockerComposeWith(opts ...ComposeStackOption) (*dockerCompose, error) {
+func NewDockerComposeWith(opts ...ComposeStackOption) (*DockerCompose, error) {
 	composeOptions := composeStackOptions{
 		Identifier:     uuid.New().String(),
 		temporaryPaths: make(map[string]bool),
@@ -162,7 +162,7 @@ func NewDockerComposeWith(opts ...ComposeStackOption) (*dockerCompose, error) {
 	dockerClient := dockerCli.Client()
 	provider.SetClient(dockerClient)
 
-	composeAPI := &dockerCompose{
+	composeAPI := &DockerCompose{
 		name:             composeOptions.Identifier,
 		configs:          composeOptions.Paths,
 		temporaryConfigs: composeOptions.temporaryPaths,
@@ -180,7 +180,7 @@ func NewDockerComposeWith(opts ...ComposeStackOption) (*dockerCompose, error) {
 	return composeAPI, nil
 }
 
-// Deprecated: NewLocalDockerCompose returns a DockerCompose compatible instance which is superseded
+// Deprecated: NewLocalDockerCompose returns a DockerComposer compatible instance which is superseded
 // by ComposeStack use NewDockerCompose instead to get a ComposeStack compatible instance
 //
 // NewLocalDockerCompose returns an instance of the local Docker Compose, using an

modules/compose/compose_api.go

@@ -180,7 +180,7 @@ const (
 	RemoveImagesLocal
 )
 
-type dockerCompose struct {
+type DockerCompose struct {
 	// used to synchronize operations
 	lock sync.RWMutex
 
@@ -235,21 +235,21 @@ type dockerCompose struct {
 	provider *testcontainers.DockerProvider
 }
 
-func (d *dockerCompose) ServiceContainer(ctx context.Context, svcName string) (*testcontainers.DockerContainer, error) {
+func (d *DockerCompose) ServiceContainer(ctx context.Context, svcName string) (*testcontainers.DockerContainer, error) {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
 	return d.lookupContainer(ctx, svcName)
 }
 
-func (d *dockerCompose) Services() []string {
+func (d *DockerCompose) Services() []string {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
 	return d.project.ServiceNames()
 }
 
-func (d *dockerCompose) Down(ctx context.Context, opts ...StackDownOption) error {
+func (d *DockerCompose) Down(ctx context.Context, opts ...StackDownOption) error {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
@@ -271,7 +271,7 @@ func (d *dockerCompose) Down(ctx context.Context, opts ...StackDownOption) error
 	return d.composeService.Down(ctx, d.name, options.DownOptions)
 }
 
-func (d *dockerCompose) Up(ctx context.Context, opts ...StackUpOption) (err error) {
+func (d *DockerCompose) Up(ctx context.Context, opts ...StackUpOption) (err error) {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
@@ -436,23 +436,23 @@ func (d *dockerCompose) Up(ctx context.Context, opts ...StackUpOption) (err erro
 	return nil
 }
 
-func (d *dockerCompose) WaitForService(s string, strategy wait.Strategy) ComposeStack {
+func (d *DockerCompose) WaitForService(s string, strategy wait.Strategy) ComposeStack {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
 	d.waitStrategies[s] = strategy
 	return d
 }
 
-func (d *dockerCompose) WithEnv(m map[string]string) ComposeStack {
+func (d *DockerCompose) WithEnv(m map[string]string) ComposeStack {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
 	d.projectOptions = append(d.projectOptions, withEnv(m))
 	return d
 }
 
-func (d *dockerCompose) WithOsEnv() ComposeStack {
+func (d *DockerCompose) WithOsEnv() ComposeStack {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
@@ -461,7 +461,7 @@ func (d *dockerCompose) WithOsEnv() ComposeStack {
 }
 
 // cachedContainer returns the cached container for svcName or nil if it doesn't exist.
-func (d *dockerCompose) cachedContainer(svcName string) *testcontainers.DockerContainer {
+func (d *DockerCompose) cachedContainer(svcName string) *testcontainers.DockerContainer {
 	d.containersLock.Lock()
 	defer d.containersLock.Unlock()
 
@@ -471,7 +471,7 @@ func (d *dockerCompose) cachedContainer(svcName string) *testcontainers.DockerCo
 // lookupContainer is used to retrieve the container instance from the cache or the Docker API.
 //
 // Safe for concurrent calls.
-func (d *dockerCompose) lookupContainer(ctx context.Context, svcName string) (*testcontainers.DockerContainer, error) {
+func (d *DockerCompose) lookupContainer(ctx context.Context, svcName string) (*testcontainers.DockerContainer, error) {
 	if c := d.cachedContainer(svcName); c != nil {
 		return c, nil
 	}
@@ -506,7 +506,7 @@ func (d *dockerCompose) lookupContainer(ctx context.Context, svcName string) (*t
 // lookupNetworks is used to retrieve the networks that are part of the compose stack.
 //
 // Safe for concurrent calls.
-func (d *dockerCompose) lookupNetworks(ctx context.Context) error {
+func (d *DockerCompose) lookupNetworks(ctx context.Context) error {
 	networks, err := d.dockerClient.NetworkList(ctx, dockernetwork.ListOptions{
 		Filters: filters.NewArgs(
 			filters.Arg("label", fmt.Sprintf("%s=%s", api.ProjectLabel, d.name)),
@@ -529,7 +529,7 @@ func (d *dockerCompose) lookupNetworks(ctx context.Context) error {
 	return nil
 }
 
-func (d *dockerCompose) compileProject(ctx context.Context) (*types.Project, error) {
+func (d *DockerCompose) compileProject(ctx context.Context) (*types.Project, error) {
 	const nameAndDefaultConfigPath = 2
 	projectOptions := make([]cli.ProjectOptionsFn, len(d.projectOptions), len(d.projectOptions)+nameAndDefaultConfigPath)
 

modules/compose/compose_api_test.go

@@ -142,14 +142,15 @@ func TestDockerComposeAPIWithProfiles(t *testing.T) {
 
 	for name, test := range testcases {
 		t.Run(name, func(t *testing.T) {
+			var compose ComposeStack
 			compose, err := NewDockerComposeWith(WithStackFiles(path), WithProfiles(test.withProfiles...))
 			require.NoError(t, err, "NewDockerCompose()")
 
 			ctx, cancel := context.WithCancel(context.Background())
 			t.Cleanup(cancel)
 
 			for _, service := range test.wantServices {
-				compose = compose.WaitForService(service, wait.NewHTTPStrategy("/").WithPort("80/tcp").WithStartupTimeout(10*time.Second)).(*dockerCompose)
+				compose = compose.WaitForService(service, wait.NewHTTPStrategy("/").WithPort("80/tcp").WithStartupTimeout(10*time.Second))
 			}
 			err = compose.Up(ctx, Wait(true))
 			cleanup(t, compose)
@@ -695,7 +696,7 @@ func testNameHash(name string) StackIdentifier {
 }
 
 // cleanup is a helper function that schedules the compose stack to be stopped when the test ends.
-func cleanup(t *testing.T, compose *dockerCompose) {
+func cleanup(t *testing.T, compose ComposeStack) {
 	t.Helper()
 	t.Cleanup(func() {
 		require.NoError(t, compose.Down(

modules/compose/compose_local.go

@@ -190,30 +190,30 @@ func (dc *LocalDockerCompose) Invoke() ExecError {
 
 // Deprecated: it will be removed in the next major release
 // WaitForService sets the strategy for the service that is to be waited on
-func (dc *LocalDockerCompose) WaitForService(service string, strategy wait.Strategy) DockerCompose {
+func (dc *LocalDockerCompose) WaitForService(service string, strategy wait.Strategy) DockerComposer {
 	dc.waitStrategySupplied = true
 	dc.WaitStrategyMap[waitService{service: service}] = strategy
 	return dc
 }
 
 // Deprecated: it will be removed in the next major release
 // WithCommand assigns the command
-func (dc *LocalDockerCompose) WithCommand(cmd []string) DockerCompose {
+func (dc *LocalDockerCompose) WithCommand(cmd []string) DockerComposer {
 	dc.Cmd = cmd
 	return dc
 }
 
 // Deprecated: it will be removed in the next major release
 // WithEnv assigns the environment
-func (dc *LocalDockerCompose) WithEnv(env map[string]string) DockerCompose {
+func (dc *LocalDockerCompose) WithEnv(env map[string]string) DockerComposer {
 	dc.Env = env
 	return dc
 }
 
 // Deprecated: it will be removed in the next major release
 // WithExposedService sets the strategy for the service that is to be waited on. If multiple strategies
 // are given for a single service running on different ports, both strategies will be applied on the same container
-func (dc *LocalDockerCompose) WithExposedService(service string, port int, strategy wait.Strategy) DockerCompose {
+func (dc *LocalDockerCompose) WithExposedService(service string, port int, strategy wait.Strategy) DockerComposer {
 	dc.waitStrategySupplied = true
 	dc.WaitStrategyMap[waitService{service: service, publishedPort: port}] = strategy
 	return dc