Initial Commit

packages/docker/tests/cleanup-job-test.ts

@@ -0,0 +1,62 @@
+import { prepareJob, cleanupJob } from '../src/hooks'
+import { v4 as uuidv4 } from 'uuid'
+import * as fs from 'fs'
+import * as path from 'path'
+import TestSetup from './test-setup'
+
+const prepareJobInputPath = path.resolve(
+  `${__dirname}/../../../examples/prepare-job.json`
+)
+
+const tmpOutputDir = `${__dirname}/${uuidv4()}`
+
+let prepareJobOutputPath: string
+let prepareJobData: any
+
+let testSetup: TestSetup
+
+jest.useRealTimers()
+
+describe('cleanup job', () => {
+  beforeAll(() => {
+    fs.mkdirSync(tmpOutputDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    fs.rmSync(tmpOutputDir, { recursive: true })
+  })
+
+  beforeEach(async () => {
+    const prepareJobRawData = fs.readFileSync(prepareJobInputPath, 'utf8')
+    prepareJobData = JSON.parse(prepareJobRawData.toString())
+
+    prepareJobOutputPath = `${tmpOutputDir}/prepare-job-output-${uuidv4()}.json`
+    fs.writeFileSync(prepareJobOutputPath, '')
+
+    testSetup = new TestSetup()
+    testSetup.initialize()
+
+    prepareJobData.args.container.userMountVolumes = testSetup.userMountVolumes
+    prepareJobData.args.container.systemMountVolumes =
+      testSetup.systemMountVolumes
+    prepareJobData.args.container.workingDirectory = testSetup.workingDirectory
+
+    await prepareJob(prepareJobData.args, prepareJobOutputPath)
+  })
+
+  afterEach(() => {
+    fs.rmSync(prepareJobOutputPath, { force: true })
+    testSetup.teardown()
+  })
+
+  it('should cleanup successfully', async () => {
+    const prepareJobOutputContent = fs.readFileSync(
+      prepareJobOutputPath,
+      'utf-8'
+    )
+    const parsedPrepareJobOutput = JSON.parse(prepareJobOutputContent)
+    await expect(
+      cleanupJob(prepareJobData.args, parsedPrepareJobOutput.state, null)
+    ).resolves.not.toThrow()
+  })
+})

packages/docker/tests/container-pull-test.ts

@@ -0,0 +1,14 @@
+import { containerPull } from '../src/dockerCommands'
+
+jest.useRealTimers()
+
+describe('container pull', () => {
+  it('should fail', async () => {
+    const arg = { image: 'doesNotExist' }
+    await expect(containerPull(arg.image, '')).rejects.toThrow()
+  })
+  it('should succeed', async () => {
+    const arg = { image: 'ubuntu:latest' }
+    await expect(containerPull(arg.image, '')).resolves.not.toThrow()
+  })
+})

packages/docker/tests/e2e-test.ts

@@ -0,0 +1,117 @@
+import {
+  prepareJob,
+  cleanupJob,
+  runScriptStep,
+  runContainerStep
+} from '../src/hooks'
+import * as fs from 'fs'
+import * as path from 'path'
+import { v4 as uuidv4 } from 'uuid'
+import TestSetup from './test-setup'
+
+const prepareJobJson = fs.readFileSync(
+  path.resolve(__dirname + '/../../../examples/prepare-job.json'),
+  'utf8'
+)
+
+const containerStepJson = fs.readFileSync(
+  path.resolve(__dirname + '/../../../examples/run-container-step.json'),
+  'utf8'
+)
+
+const tmpOutputDir = `${__dirname}/_temp/${uuidv4()}`
+
+let prepareJobData: any
+let scriptStepJson: any
+let scriptStepData: any
+let containerStepData: any
+
+let prepareJobOutputFilePath: string
+
+let testSetup: TestSetup
+
+describe('e2e', () => {
+  beforeAll(() => {
+    fs.mkdirSync(tmpOutputDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    fs.rmSync(tmpOutputDir, { recursive: true })
+  })
+
+  beforeEach(() => {
+    // init dirs
+    testSetup = new TestSetup()
+    testSetup.initialize()
+
+    prepareJobData = JSON.parse(prepareJobJson)
+    prepareJobData.args.container.userMountVolumes = testSetup.userMountVolumes
+    prepareJobData.args.container.systemMountVolumes =
+      testSetup.systemMountVolumes
+    prepareJobData.args.container.workingDirectory = testSetup.workingDirectory
+
+    scriptStepJson = fs.readFileSync(
+      path.resolve(__dirname + '/../../../examples/run-script-step.json'),
+      'utf8'
+    )
+    scriptStepData = JSON.parse(scriptStepJson)
+    scriptStepData.args.workingDirectory = testSetup.workingDirectory
+
+    containerStepData = JSON.parse(containerStepJson)
+    containerStepData.args.workingDirectory = testSetup.workingDirectory
+    containerStepData.args.userMountVolumes = testSetup.userMountVolumes
+    containerStepData.args.systemMountVolumes = testSetup.systemMountVolumes
+
+    prepareJobOutputFilePath = `${tmpOutputDir}/prepare-job-output-${uuidv4()}.json`
+    fs.writeFileSync(prepareJobOutputFilePath, '')
+  })
+
+  afterEach(() => {
+    fs.rmSync(prepareJobOutputFilePath, { force: true })
+    testSetup.teardown()
+  })
+
+  it('should prepare job, then run script step, then run container step then cleanup', async () => {
+    await expect(
+      prepareJob(prepareJobData.args, prepareJobOutputFilePath)
+    ).resolves.not.toThrow()
+    let rawState = fs.readFileSync(prepareJobOutputFilePath, 'utf-8')
+    let resp = JSON.parse(rawState)
+    await expect(
+      runScriptStep(scriptStepData.args, resp.state)
+    ).resolves.not.toThrow()
+    await expect(
+      runContainerStep(containerStepData.args, resp.state)
+    ).resolves.not.toThrow()
+    await expect(cleanupJob(resp, resp.state, null)).resolves.not.toThrow()
+  })
+
+  it('should prepare job, then run script step, then run container step with Dockerfile then cleanup', async () => {
+    await expect(
+      prepareJob(prepareJobData.args, prepareJobOutputFilePath)
+    ).resolves.not.toThrow()
+    let rawState = fs.readFileSync(prepareJobOutputFilePath, 'utf-8')
+    let resp = JSON.parse(rawState)
+    await expect(
+      runScriptStep(scriptStepData.args, resp.state)
+    ).resolves.not.toThrow()
+
+    const dockerfilePath = `${tmpOutputDir}/Dockerfile`
+    fs.writeFileSync(
+      dockerfilePath,
+      `FROM ubuntu:latest
+ENV TEST=test
+ENTRYPOINT [ "tail", "-f", "/dev/null" ]
+    `
+    )
+    const containerStepDataCopy = JSON.parse(JSON.stringify(containerStepData))
+    process.env.GITHUB_WORKSPACE = tmpOutputDir
+    containerStepDataCopy.args.dockerfile = 'Dockerfile'
+    containerStepDataCopy.args.context = '.'
+    console.log(containerStepDataCopy.args)
+    await expect(
+      runContainerStep(containerStepDataCopy.args, resp.state)
+    ).resolves.not.toThrow()
+    await expect(cleanupJob(resp, resp.state, null)).resolves.not.toThrow()
+  })
+})

packages/docker/tests/prepare-job-test.ts

@@ -0,0 +1,103 @@
+import * as fs from 'fs'
+import { v4 as uuidv4 } from 'uuid'
+import { prepareJob } from '../src/hooks'
+import TestSetup from './test-setup'
+
+jest.useRealTimers()
+
+let prepareJobOutputPath: string
+let prepareJobData: any
+const tmpOutputDir = `${__dirname}/_temp/${uuidv4()}`
+const prepareJobInputPath = `${__dirname}/../../../examples/prepare-job.json`
+
+let testSetup: TestSetup
+
+describe('prepare job', () => {
+  beforeAll(() => {
+    fs.mkdirSync(tmpOutputDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    fs.rmSync(tmpOutputDir, { recursive: true })
+  })
+
+  beforeEach(async () => {
+    testSetup = new TestSetup()
+    testSetup.initialize()
+
+    let prepareJobRawData = fs.readFileSync(prepareJobInputPath, 'utf8')
+    prepareJobData = JSON.parse(prepareJobRawData.toString())
+
+    prepareJobData.args.container.userMountVolumes = testSetup.userMountVolumes
+    prepareJobData.args.container.systemMountVolumes =
+      testSetup.systemMountVolumes
+    prepareJobData.args.container.workingDirectory = testSetup.workingDirectory
+
+    prepareJobOutputPath = `${tmpOutputDir}/prepare-job-output-${uuidv4()}.json`
+    fs.writeFileSync(prepareJobOutputPath, '')
+  })
+
+  afterEach(() => {
+    testSetup.teardown()
+  })
+
+  it('should not throw', async () => {
+    await expect(
+      prepareJob(prepareJobData.args, prepareJobOutputPath)
+    ).resolves.not.toThrow()
+
+    expect(() => fs.readFileSync(prepareJobOutputPath, 'utf-8')).not.toThrow()
+  })
+
+  it('should have JSON output written to a file', async () => {
+    await prepareJob(prepareJobData.args, prepareJobOutputPath)
+    const prepareJobOutputContent = fs.readFileSync(
+      prepareJobOutputPath,
+      'utf-8'
+    )
+    expect(() => JSON.parse(prepareJobOutputContent)).not.toThrow()
+  })
+
+  it('should have context written to a file', async () => {
+    await prepareJob(prepareJobData.args, prepareJobOutputPath)
+    const prepareJobOutputContent = fs.readFileSync(
+      prepareJobOutputPath,
+      'utf-8'
+    )
+    const parsedPrepareJobOutput = JSON.parse(prepareJobOutputContent)
+    expect(parsedPrepareJobOutput.context).toBeDefined()
+  })
+
+  it('should have container ids written to file', async () => {
+    await prepareJob(prepareJobData.args, prepareJobOutputPath)
+    const prepareJobOutputContent = fs.readFileSync(
+      prepareJobOutputPath,
+      'utf-8'
+    )
+    const parsedPrepareJobOutput = JSON.parse(prepareJobOutputContent)
+
+    expect(parsedPrepareJobOutput.context.container.id).toBeDefined()
+    expect(typeof parsedPrepareJobOutput.context.container.id).toBe('string')
+    expect(parsedPrepareJobOutput.context.container.id).toMatch(/^[0-9a-f]+$/)
+  })
+
+  it('should have ports for context written in form [containerPort]:[hostPort]', async () => {
+    await prepareJob(prepareJobData.args, prepareJobOutputPath)
+    const prepareJobOutputContent = fs.readFileSync(
+      prepareJobOutputPath,
+      'utf-8'
+    )
+    const parsedPrepareJobOutput = JSON.parse(prepareJobOutputContent)
+
+    const mainContainerPorts = parsedPrepareJobOutput.context.container.ports
+    expect(mainContainerPorts['8080']).toBe('80')
+
+    const redisService = parsedPrepareJobOutput.context.services.find(
+      s => s.image === 'redis'
+    )
+
+    const redisServicePorts = redisService.ports
+    expect(redisServicePorts['80']).toBe('8080')
+    expect(redisServicePorts['8080']).toBe('8088')
+  })
+})

packages/docker/tests/test-setup.ts

@@ -0,0 +1,112 @@
+import * as fs from 'fs'
+import { v4 as uuidv4 } from 'uuid'
+import { env } from 'process'
+import { Mount } from 'hooklib'
+
+export default class TestSetup {
+  private testdir: string
+  private runnerMockDir: string
+  private runnerMockSubdirs = {
+    work: '_work',
+    externals: 'externals',
+    workTemp: '_work/_temp',
+    workActions: '_work/_actions',
+    workTool: '_work/_tool',
+    githubHome: '_work/_temp/_github_home',
+    githubWorkflow: '_work/_temp/_github_workflow'
+  }
+
+  private readonly projectName = 'example'
+
+  constructor() {
+    this.testdir = `${__dirname}/_temp/${uuidv4()}`
+    this.runnerMockDir = `${this.testdir}/runner/_layout`
+  }
+
+  private get allTestDirectories() {
+    const resp = [this.testdir, this.runnerMockDir]
+
+    for (const [key, value] of Object.entries(this.runnerMockSubdirs)) {
+      resp.push(`${this.runnerMockDir}/${value}`)
+    }
+
+    resp.push(
+      `${this.runnerMockDir}/_work/${this.projectName}/${this.projectName}`
+    )
+
+    return resp
+  }
+
+  public initialize(): void {
+    for (const dir of this.allTestDirectories) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    env['RUNNER_NAME'] = 'test'
+    env[
+      'RUNNER_TEMP'
+    ] = `${this.runnerMockDir}/${this.runnerMockSubdirs.workTemp}`
+  }
+
+  public teardown(): void {
+    fs.rmdirSync(this.testdir, { recursive: true })
+  }
+
+  public get userMountVolumes(): Mount[] {
+    return [
+      {
+        sourceVolumePath: 'my_docker_volume',
+        targetVolumePath: '/volume_mount',
+        readOnly: false
+      }
+    ]
+  }
+
+  public get systemMountVolumes(): Mount[] {
+    return [
+      {
+        sourceVolumePath: '/var/run/docker.sock',
+        targetVolumePath: '/var/run/docker.sock',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.work}`,
+        targetVolumePath: '/__w',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.externals}`,
+        targetVolumePath: '/__e',
+        readOnly: true
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.workTemp}`,
+        targetVolumePath: '/__w/_temp',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.workActions}`,
+        targetVolumePath: '/__w/_actions',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.workTool}`,
+        targetVolumePath: '/__w/_tool',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.githubHome}`,
+        targetVolumePath: '/github/home',
+        readOnly: false
+      },
+      {
+        sourceVolumePath: `${this.runnerMockDir}/${this.runnerMockSubdirs.githubWorkflow}`,
+        targetVolumePath: '/github/workflow',
+        readOnly: false
+      }
+    ]
+  }
+
+  public get workingDirectory(): string {
+    return `/__w/${this.projectName}/${this.projectName}`
+  }
+}

packages/docker/tests/utils-test.ts

@@ -0,0 +1,12 @@
+import { sanitize } from '../src/utils'
+
+describe('Utilities', () => {
+  it('should return sanitized image name', () => {
+    expect(sanitize('ubuntu:latest')).toBe('ubuntulatest')
+  })
+
+  it('should return the same string', () => {
+    const validStr = 'teststr8_one'
+    expect(sanitize(validStr)).toBe(validStr)
+  })
+})