Merge pull request #784 from smartlyio/anttiharju/docker-compose

Add fallback to `docker compose` for `docker compose` for `v2`

Author: peterjenkins1

__tests__/compose.test.ts

@@ -1,5 +1,11 @@
 import {Context} from '../src/context';
-import {runCompose, runAction, runCleanup, ComposeError} from '../src/compose';
+import {
+  runCompose,
+  runAction,
+  runCleanup,
+  ComposeError,
+  composeCommand
+} from '../src/compose';
 import {mocked} from 'jest-mock';
 import {exec} from '@actions/exec';
 
@@ -11,12 +17,61 @@ const OLD_ENV = process.env;
 beforeEach(() => {
   process.env = {...OLD_ENV};
   mocked(exec).mockReset();
+  composeCommand.init(); // In most tests we are not interested in testing the docker-compose/docker compose fallback logic
 });
 
 afterEach(() => {
   process.env = OLD_ENV;
 });
 
+describe('fall back to docker compose', () => {
+  test('basic command', async () => {
+    composeCommand.reset(); // Here we are interested in the fallback logic
+    const command = 'build';
+    const projectName = 'test-name';
+    const context: Context = {
+      composeFiles: ['docker-compose.ci.yml'],
+      serviceName: 'test',
+      composeCommand: 'up',
+      composeArguments: ['--abort-on-container-exit'],
+      runCommand: [],
+      build: true,
+      buildArgs: [],
+      registryCache: 'hub.artifactor.ee',
+      push: false,
+      postCommand: ['down --remove-orphans --volumes', 'rm -f'],
+      isPost: false,
+      projectName: projectName
+    };
+
+    const mockExec = mocked(exec);
+    mockExec.mockRejectedValueOnce(new Error('docker-compose not found'));
+    mockExec.mockResolvedValue(0);
+
+    await runCompose(command, [], context);
+
+    const calls = mockExec.mock.calls;
+    expect(calls.length).toBe(2);
+
+    const expectedArgs: string[] = [
+      '-f',
+      context.composeFiles[0],
+      '-p',
+      projectName,
+      command
+    ];
+    expect(mockExec).toHaveBeenNthCalledWith(1, 'docker-compose', [
+      '--version'
+    ]);
+    expect(mockExec).toHaveBeenNthCalledWith(
+      2,
+      'docker compose',
+      expectedArgs,
+      undefined
+    );
+  });
+});
+
 describe('run docker-compose', () => {
   test('basic command', async () => {
     const command = 'build';

src/compose.ts

@@ -13,6 +13,44 @@ export class ComposeError extends Error {
   }
 }
 
+class ComposeCommand {
+  // Not using a constructor as the singleton implementation due to await, constructors can't be async.
+  private initialised = false;
+  private composeCommand = 'docker-compose';
+
+  /**
+   * Checks docker-compose availability, using docker compose as fallback.
+   *
+   * @returns {Promise<string>} 'docker-compose' or 'docker compose'
+   */
+  async get(): Promise<string> {
+    if (!this.initialised) {
+      this.initialised = true;
+      try {
+        await exec.exec('docker-compose', ['--version']);
+      } catch (error) {
+        console.warn(
+          'docker-compose not available, falling back to docker compose'
+        );
+        this.composeCommand = 'docker compose';
+      }
+    }
+    return this.composeCommand;
+  }
+
+  init(): void {
+    this.initialised = true;
+    this.composeCommand = 'docker-compose';
+  }
+
+  reset(): void {
+    this.initialised = false;
+    this.composeCommand = 'docker-compose';
+  }
+}
+
+export const composeCommand = new ComposeCommand();
+
 export async function runCompose(
   command: string,
   args: string[],
@@ -30,7 +68,8 @@ export async function runCompose(
   for (const part of args) {
     composeArgs.push(part);
   }
-  return await exec.exec('docker-compose', composeArgs, execOptions);
+  const dockerCompose = await composeCommand.get();
+  return await exec.exec(dockerCompose, composeArgs, execOptions);
 }
 
 export async function getContainerId(context: Context): Promise<string | null> {