@codedependant/semantic-release-docker 3.1.1

package/test/unit/docker/image.js

@@ -0,0 +1,289 @@
+'use strict'
+
+const os = require('os')
+const path = require('path')
+const crypto = require('crypto')
+const execa = require('execa')
+const {test, threw} = require('tap')
+const docker = require('../../../lib/docker/index.js')
+
+function random() {
+  return crypto.randomBytes(5).toString('hex')
+}
+
+const fixturedir = path.join(__dirname, '..', '..', 'fixture')
+test('exports', async (tt) => {
+  tt.match(docker, {
+    Image: Function
+  }, 'expected exports')
+})
+
+test('Image', async (t) => {
+  const build_id = random()
+  t.throws(() => {
+    return new docker.Image()
+  }, /docker image "name" is required and must be a string/gi)
+
+  t.test('image defaults', async (tt) => {
+    const img = new docker.Image({name: 'test'})
+    tt.notOk(img.sha, 'No default sha generated')
+    tt.match(img.opts, {
+      build_id: String
+    , registry: null
+    , project: null
+    , name: 'test'
+    , dockerfile: 'Dockerfile'
+    , cwd: process.cwd()
+    , args: Map
+    }, 'default image options')
+  })
+
+  test('image overrides', async (tt) => {
+    const img = new docker.Image({
+      name: 'test'
+    , build_id: 'abc123'
+    , registry: 'quay.io'
+    , project: 'esatterwhite'
+    , name: 'test'
+    , dockerfile: 'Dockerfile.test'
+    , cwd: path.join(__dirname, 'build')
+    , sha: 'hello'
+    })
+    tt.equal(img.sha, 'hello')
+    tt.match(img.opts, {
+      build_id: 'abc123'
+    , registry: 'quay.io'
+    , project: 'esatterwhite'
+    , name: 'test'
+    , dockerfile: 'Dockerfile.test'
+    , cwd: path.join(__dirname, 'build')
+    , args: Map
+    }, 'default image options')
+
+    tt.equal(img.context, '.', 'default image context')
+    img.context = __dirname
+    tt.equal(img.context, __dirname, 'context override')
+    tt.equal(
+      img.dockerfile
+    , path.join(__dirname, 'build', 'Dockerfile.test')
+    , 'docker file path'
+    )
+  })
+
+  t.test('dockerfile location resolution', async (t) => {
+    t.test('relative location', async (t) => {
+      const img = new docker.Image({
+        name: 'test'
+      , build_id: 'abc123'
+      , registry: 'quay.io'
+      , project: 'esatterwhite'
+      , name: 'test'
+      , dockerfile: '../../Dockerfile.test'
+      , cwd: path.join(__dirname, 'build')
+      , sha: 'hello'
+      })
+      t.equal(
+        img.dockerfile
+      , path.join(__dirname, '..', 'Dockerfile.test')
+      , 'docker file path'
+      )
+    })
+
+    t.test('absolute path', async (t) => {
+      const img = new docker.Image({
+        name: 'test'
+      , build_id: 'abc123'
+      , registry: 'quay.io'
+      , project: 'esatterwhite'
+      , name: 'test'
+      , dockerfile: '/var/opt/Dockerfile.test'
+      , cwd: path.join(__dirname, 'build')
+      , sha: 'hello'
+      })
+      t.equal(
+        img.dockerfile
+      , '/var/opt/Dockerfile.test'
+      , 'docker file path'
+      )
+    })
+  })
+
+  t.test('image#id()', async (tt) => {
+    {
+      const img = new docker.Image({
+        name: 'test'
+      , build_id: 'abc123'
+      })
+
+      tt.equal(img.id, 'test:abc123')
+    }
+
+    {
+      const img = new docker.Image({
+        name: 'test'
+      , sha: 'abcdefg123456'
+      , registry: 'quay.io'
+      , project: 'esatterwhite'
+      , build_id: 'abacadaba'
+      })
+
+      tt.equal(img.id, 'abcdefg123456', 'sha value used as image id')
+    }
+  })
+
+  t.test('image#repo', async (tt) => {
+    {
+      const img = new docker.Image({
+        name: 'test'
+      })
+
+      tt.equal(img.repo, 'test')
+    }
+
+    {
+      const img = new docker.Image({
+        name: 'foobar'
+      , registry: 'us.gcr.io'
+      })
+
+      tt.equal(img.repo, 'us.gcr.io/foobar')
+    }
+
+    {
+      const img = new docker.Image({
+        name: 'test'
+      , registry: 'quay.io'
+      , project: 'esatterwhite'
+      })
+
+      tt.equal(img.repo, 'quay.io/esatterwhite/test', 'generated repo name')
+    }
+  })
+
+  t.test('image#build_cmd', async (tt) => {
+    {
+      const img = new docker.Image({
+        name: 'test'
+      , registry: 'quay.io'
+      , project: 'esatterwhite'
+      , build_id: 'abacadaba'
+      })
+
+      tt.deepEqual(img.build_cmd, [
+        'build'
+      , '--quiet'
+      , '--tag'
+      , 'quay.io/esatterwhite/test:abacadaba'
+      , '-f'
+      , path.join(process.cwd(), 'Dockerfile')
+      , '.'
+      ], 'build command')
+    }
+
+    {
+      const img = new docker.Image({
+        name: 'foobar'
+      , registry: 'us.gcr.io'
+      , project: 'esatterwhite'
+      , build_id: '1010101'
+      , cwd: __dirname
+      , context: path.join(__dirname, 'fake')
+      })
+
+      tt.deepEqual(img.build_cmd, [
+        'build'
+      , '--quiet'
+      , '--tag'
+      , 'us.gcr.io/esatterwhite/foobar:1010101'
+      , '-f'
+      , path.join(__dirname, 'Dockerfile')
+      , path.join(__dirname, 'fake')
+      ], 'build command')
+    }
+
+    {
+      const img = new docker.Image({
+        name: 'foobar'
+      , registry: 'us.gcr.io'
+      , project: 'esatterwhite'
+      , build_id: '1010101'
+      , cwd: __dirname
+      , context: path.join(__dirname, 'fake')
+      })
+
+      img.arg('ARG_1', 'yes')
+      img.arg('VALUE_FROM_ENV', true)
+      tt.deepEqual(img.build_cmd, [
+        'build'
+      , '--quiet'
+      , '--tag'
+      , 'us.gcr.io/esatterwhite/foobar:1010101'
+      , '--build-arg'
+      , 'ARG_1=yes'
+      , '--build-arg'
+      , 'VALUE_FROM_ENV'
+      , '-f'
+      , path.join(__dirname, 'Dockerfile')
+      , path.join(__dirname, 'fake')
+      ], 'build command')
+    }
+  })
+
+  t.test('image#build()', async (tt) => {
+    const img = new docker.Image({
+      name: 'test'
+    , registry: 'quay.io'
+    , project: 'esatterwhite'
+    , build_id: build_id
+    , cwd: fixturedir
+    , dockerfile: path.join('docker', 'Dockerfile.test')
+    , context: path.join(fixturedir, 'docker')
+    })
+
+    tt.notOk(img.sha, 'no show before build')
+    const sha = await img.build()
+    tt.equal(sha, img.sha, 'image sha set after build')
+    const {stdout} = await execa('docker', ['run', '--rm', img.name, 'ls', '-1'])
+    tt.deepEqual(
+      stdout.split(os.EOL).sort()
+    , ['Dockerfile.test', 'Dockerfile.publish', 'Dockerfile.prepare'].sort()
+    , 'files in image context')
+  })
+
+  t.test('image#tag()', async (tt) => {
+    const img = new docker.Image({
+      name: 'test'
+    , registry: 'quay.io'
+    , project: 'esatterwhite'
+    , build_id: build_id
+    , cwd: __dirname
+    , dockerfile: path.join(fixturedir, 'docker', 'Dockerfile.test')
+    , context: path.join(__dirname, 'fixture')
+    })
+    await img.tag('1.0.0', false)
+    const {stdout} = await execa('docker', [
+      'images', img.repo
+    , '-q', '--format={{ .Tag }}'
+    ])
+    const tags = stdout.split(os.EOL)
+    tt.deepEqual(tags.sort(), [build_id, '1.0.0'].sort(), 'image tags')
+  })
+
+  t.test('image#clean()', async (tt) => {
+    const img = new docker.Image({
+      name: 'test'
+    , registry: 'quay.io'
+    , project: 'esatterwhite'
+    , build_id: build_id
+    , cwd: __dirname
+    , dockerfile: path.join('fixture', 'Dockerfile.test')
+    })
+    await img.clean()
+    const {stdout} = await execa('docker', [
+      'images', img.repo
+    , '-q', '--format={{ .Tag }}'
+    ])
+    tt.deepEqual(stdout, '', 'all tags removed')
+  })
+
+}).catch(threw)

package/test/unit/lang/array.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const {test, threw} = require('tap')
+const array = require('../../../lib/lang/array/index.js')
+
+test('array', async (t) => {
+  t.test('toArray', async (t) => {
+    const cases = [
+      {value: undefined, expected: [], message: 'toArray(undefined) == []'}
+    , {value: null, expected: [], message: 'toArray(null) == []'}
+    , {value: 1, expected: [1], message: 'toArray(1) == [1]'}
+    , {value: '', expected: [], message: 'toArray(\'\') == []'}
+    , {value: 'test', expected: ['test']}
+    , {value: '1,2,3', expected: ['1', '2', '3']}
+    , {value: '1, 2, 3', expected: ['1', '2', '3']}
+    , {value: '1, 2, 3', expected: ['1', ' 2', ' 3'], sep: ','}
+    , {value: '1|2|3', expected: ['1', '2', '3'], sep: '|'}
+    , {value: [1, 2, 3], expected: [1, 2, 3]}
+    , {value: new Set([1, null, 'test']), expected: [1, null, 'test']}
+    ]
+    for (const current of cases) {
+      const args = [current.value]
+      if (current.sep) {
+        args.push(current.sep)
+      }
+
+      t.deepEqual(
+        array.toArray(...args)
+      , current.expected
+      , current.message || `toArray(${current.value}) == ${current.expected}`
+      )
+    }
+  })
+}).catch(threw)

package/test/unit/lang/object.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const {test, threw} = require('tap')
+const object = require('../../../lib/lang/object/index.js')
+
+test('object', async (t) => {
+  const obj = {
+    foo: {
+      bar: {
+        baz: {
+          key: 'value'
+        , test: null
+        }
+      }
+    , value: 'foobar'
+    , array: [1, 2, 3]
+    }
+  , bar: 0
+  , baz: false
+  , biff: null
+  }
+
+  t.test('get', async (tt) => {
+    tt.match(object.get(obj, 'foo.bar'), {
+      baz: {
+        key: 'value'
+      , test: null
+      }
+    })
+    tt.deepEqual(object.get(obj, 'foo.array'), [1, 2, 3], 'foo.array')
+    tt.equal(object.get(obj, 'foo.bar.baz.key'), 'value', 'foo.bar.baz.key')
+    tt.equal(object.get(obj, 'foo|bar|baz|key', '|'), 'value', 'foo.bar.baz.key')
+    tt.equal(object.get(obj, 'does.not.exist'), undefined, 'does.not.exist')
+    tt.strictEqual(object.get(obj, 'foo.bar.baz.test'), null, 'foo.bar.baz.test')
+    tt.strictEqual(object.get(null, 'foo.bar.baz'), null, 'null input')
+  })
+
+  t.test('has', async (t) => {
+    t.ok(object.has(obj, 'bar'), 'key found')
+    t.ok(object.has(obj, 'biff'), 'has key w/ null value')
+    t.false(object.has(obj, 'whizbang'), 'key not found')
+    t.false(object.has(undefined, 'whizbang'), 'undefined object')
+
+  })
+}).catch(threw)

package/test/unit/lang/string.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const {test, threw} = require('tap')
+const string = require('../../../lib/lang/string/index.js')
+
+test('string', async (t) => {
+  t.test('template', async (tt) => {
+    const cases = [
+      {
+        input: 'hello {value}'
+      , values: {value: 'world'}
+      , expected: 'hello world'
+      , message: 'single value lookup'
+      }, {
+        input: 'hello {value}'
+      , values: {}
+      , expected: 'hello {value}'
+      , message: 'missing imput values'
+      }, {
+        input: 'hello {place.name}'
+      , values: {place: {name: 'boston'}}
+      , expected: 'hello boston'
+      , message: 'nested values'
+      }, {
+        input: null
+      , values: {place: {name: 'boston'}}
+      , expected: null
+      , message: 'non string value returns value'
+      }
+    ]
+
+    for (const tcase of cases) {
+      const tpl = string.template(tcase.input)
+      tt.equal(tpl(tcase.values), tcase.expected, tcase.message)
+    }
+  })
+}).catch(threw)

package/test/unit/parse-pkg-name.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const {test, threw} = require('tap')
+const parsePkgName = require('../../lib/parse-pkg-name.js')
+
+test('parsePkgName', async (t) => {
+  t.deepEqual(parsePkgName('test'), {
+    scope: null
+  , name: 'test'
+  }, 'non-scoped package name')
+
+  t.deepEqual(parsePkgName('@namespace/foobar'), {
+    scope: 'namespace'
+  , name: 'foobar'
+  }, 'scoped package name')
+
+  t.deepEqual(parsePkgName('nampace/foobar'), {
+    name: null
+  , scope: null
+  }, 'invalid package name')
+
+  t.deepEqual(parsePkgName(), {
+    name: null
+  , scope: null
+  }, 'no package name')
+
+}).catch(threw)

package/test/unit/read-pkg.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const path = require('path')
+const {test, threw} = require('tap')
+const readPkg = require('../../lib/read-pkg.js')
+
+const fixturedir = path.join(__dirname, '..', 'fixture')
+test('read-pkg', async (t) => {
+  t.test('reads cwd by default', async (tt) => {
+    const pkg = await readPkg()
+    tt.match(pkg, {
+      name: '@codedependant/semantic-release-docker'
+    , version: String
+    })
+  })
+
+  t.test('reads specified directories', async (tt) => {
+    const cwd = path.join(fixturedir, 'pkg', 'one')
+    const pkg = await readPkg({cwd})
+    tt.match(pkg, {
+      name: '@fixture/one'
+    , version: '0.0.0'
+    , private: true
+    })
+  })
+
+  t.test('throws on invalid json', async (tt) => {
+    const cwd = path.join(fixturedir, 'pkg', 'two')
+    tt.rejects(readPkg({cwd}), /unexpected end of json input/ig)
+  })
+
+  t.test('throws if no package.json', async (tt) => {
+    const cwd = path.join(fixturedir, 'pkg', 'three')
+    tt.rejects(readPkg({cwd}), {code: 'ENOENT'})
+  })
+}).catch(threw)