@toa.io/operations 0.4.0-dev.6 → 0.4.0-dev.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/operations",
-  "version": "0.4.0-dev.6",
+  "version": "0.4.0-dev.9",
   "description": "Toa Deployment",
   "homepage": "https://toa.io",
   "author": {
@@ -26,9 +26,9 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/filesystem": "0.4.0-dev.6",
-    "@toa.io/generic": "0.4.0-dev.6",
-    "@toa.io/yaml": "0.4.0-dev.6",
+    "@toa.io/filesystem": "0.4.0-dev.9",
+    "@toa.io/generic": "0.4.0-dev.9",
+    "@toa.io/yaml": "0.4.0-dev.9",
     "execa": "5.1.1"
   },
   "gitHead": "2be07592325b2e4dc823e81d882a4e50bf50de24"

package/src/deployment/.deployment/.describe/variables.js

@@ -11,7 +11,7 @@ const variables = (context, variables) => {
   if (context.environment !== undefined) {
     const variable = format('TOA_ENV', context.environment)
 
-    variables.global.push(variable)
+    variables.global.unshift(variable)
   }
 
   return variables

package/src/deployment/deployment.js

@@ -13,10 +13,13 @@ const { merge, declare, describe } = require('./.deployment')
 class Deployment {
   /** @type {toa.deployment.Declaration} */
   #declaration
+
   /** @type {toa.deployment.Contents} */
   #contents
+
   /** @type {toa.operations.Process} */
   #process
+
   /** @type {string} */
   #target
 
@@ -29,8 +32,6 @@ class Deployment {
   constructor (context, compositions, dependencies, process) {
     const dependency = merge(dependencies)
 
-    if (context.environment === 'local') throw new Error('Deployment environment name \'local\' is not allowed.')
-
     this.#declaration = declare(context, dependency)
     this.#contents = describe(context, compositions, dependency)
     this.#process = process
@@ -75,6 +76,10 @@ class Deployment {
       ['template', this.#declaration.name, ...args, this.#target],
       { silently: true })
   }
+
+  variables () {
+    return this.#contents.variables
+  }
 }
 
 const TEMPLATES = join(__dirname, 'chart/templates')

package/src/deployment/operator.js

@@ -64,6 +64,10 @@ class Operator {
     return output
   }
 
+  variables () {
+    return this.#deployment.variables()
+  }
+
   /**
    * @param type {string}
    * @param [path] {string}

package/test/deployment/deployment.fixtures.js

@@ -4,8 +4,30 @@ const { generate } = require('randomstring')
 
 const context = /** @type {toa.norm.Context} */ { name: generate() }
 const compositions = []
-const dependencies = []
+/** @type {toa.deployment.Dependency[]} */
+
+/** @type {toa.deployment.dependency.Variable} */
+const bindingVariable = {
+  name: 'TOA_BINDINGS_AMQP_POINTER',
+  value: 'eyJkZWZhdWx0IjoiYW1xcDovL3doYXRldmVyIiwic3lzdGVtIjoiYW1xcDovL2hvc3QwIn0='
+}
+
+/** @type {toa.deployment.dependency.Variable} */
+const secretVariable = {
+  name: 'TOA_BINDINGS_AMQP_DEFAULT_USERNAME',
+  secret: {
+    name: 'toa-bindings-amqp-default',
+    key: 'username'
+  }
+}
+
+/** @type {toa.deployment.Dependency[]} */
+const dependencies = [{
+  variables: { global: [bindingVariable, secretVariable] }
+}]
+
 const process = /** @type {toa.operations.Process} */ { execute: jest.fn() }
+
 const options = /** @type {toa.deployment.installation.Options} */ {
   namespace: generate(),
   target: generate()
@@ -16,3 +38,5 @@ exports.compositions = compositions
 exports.dependencies = dependencies
 exports.process = process
 exports.options = options
+exports.bindingVariable = bindingVariable
+exports.secretVariable = secretVariable

package/test/deployment/deployment.test.js

@@ -30,12 +30,49 @@ it('should pass -n argument if options.namespace is set', async () => {
   expect(namespace).toStrictEqual(fixtures.options.namespace)
 })
 
-it('should forbid local deployment environment', () => {
-  const context = clone(fixtures.context)
+describe('variables', () => {
+  let deployment /** @type {toa.deployment.Deployment} */
 
-  context.environment = 'local'
+  it('should be define', () => {
+    const context = clone(fixtures.context)
 
-  const create = () => new Deployment(context, fixtures.compositions, fixtures.dependencies, fixtures.process)
+    deployment = new Deployment(context, fixtures.compositions, fixtures.dependencies, fixtures.process)
 
-  expect(create).toThrow(/name 'local' is not allowed/)
+    expect(typeof deployment.variables).toBe('function')
+  })
+
+  it('should return variables', () => {
+    const context = clone(fixtures.context)
+    const [{ variables }] = fixtures.dependencies
+
+    deployment = new Deployment(context, fixtures.compositions, fixtures.dependencies, fixtures.process)
+    expect(deployment.variables()).toEqual(variables)
+  })
+
+  it('should return variables', () => {
+    const context = clone(fixtures.context)
+    const [{ variables }] = fixtures.dependencies
+
+    deployment = new Deployment(context, fixtures.compositions, fixtures.dependencies, fixtures.process)
+
+    expect(deployment.variables()).toEqual(variables)
+  })
+
+  it('should merge all variables', () => {
+    const context = clone(fixtures.context)
+
+    /** @type {toa.deployment.Dependency} */
+    const dep1 = { variables: { global: [fixtures.secretVariable] } }
+
+    /** @type {toa.deployment.Dependency} */
+    const dep2 = { variables: { global: [fixtures.bindingVariable] } }
+
+    deployment = new Deployment(context, fixtures.compositions, [dep1, dep2], fixtures.process)
+
+    const result = deployment.variables()
+    const expectedVariables = [fixtures.bindingVariable, fixtures.secretVariable]
+
+    expect(result.global.length).toBe(expectedVariables.length)
+    expect(result.global).toStrictEqual(expect.arrayContaining(expectedVariables))
+  })
 })

package/test/deployment/operator.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { Operator } = require('../../src/deployment/operator')
+const { generate } = require('randomstring')
+
+it('should be', async () => {
+  expect(Operator).toBeInstanceOf(Function)
+})
+
+/** @type {toa.deployment.Operator} */
+let operator
+
+describe('env', () => {
+  /** @type {toa.deployment.Deployment} */
+  let deployment
+
+  /** @type {toa.deployment.images.Registry} */
+  let registry
+
+  beforeEach(() => {
+    deployment = /** @type {toa.deployment.Deployment} */ {}
+    registry = /** @type {toa.deployment.images.Registry} */ {}
+  })
+
+  it('should be', async () => {
+    operator = new Operator(deployment, registry)
+
+    expect(operator.variables).toBeInstanceOf(Function)
+  })
+
+  it('should return variables', async () => {
+    const variables = { [generate()]: { name: generate(), value: generate() } }
+
+    deployment.variables = jest.fn(() => variables)
+    operator = new Operator(deployment, registry)
+
+    const output = operator.variables()
+
+    expect(output).toStrictEqual(variables)
+  })
+})

package/types/deployment/deployment.d.ts

@@ -6,62 +6,65 @@ import type { dependency } from './dependency'
 
 declare namespace toa.deployment {
 
-    interface Declaration {
-        apiVersion: string
-        type: string
-        name: string
-        description?: string
-        version: string
-        appVersion: string
-        dependencies: dependency.Reference[]
+  interface Declaration {
+    apiVersion: string
+    type: string
+    name: string
+    description?: string
+    version: string
+    appVersion: string
+    dependencies: dependency.Reference[]
+  }
+
+  interface Contents {
+    compositions?: Composition[]
+    components?: string[]
+    services?: Service[]
+    proxies?: dependency.Proxy[]
+    variables?: dependency.Variables
+
+    [key: string]: Object
+  }
+
+  namespace installation {
+
+    interface Options {
+      wait?: boolean
+      target?: string
+      namespace?: string
     }
 
-    interface Contents {
-        compositions?: Composition[]
-        components?: string[]
-        services?: Service[]
-        proxies?: dependency.Proxy[]
-        variables?: dependency.Variables
-        [key: string]: Object
-    }
-
-    namespace installation {
-
-        interface Options {
-            wait?: boolean
-            target?: string
-            namespace?: string
-        }
+  }
 
+  namespace template {
+    interface Options {
+      namespace: string
     }
+  }
 
-    namespace template {
-        interface Options {
-            namespace: string
-        }
-    }
+  interface Deployable {
+    name: string
+    image: string
+  }
 
-    interface Deployable {
-        name: string
-        image: string
-    }
+  interface Deployment {
+    export(target: string): Promise<void>
 
-    interface Deployment {
-        export(target: string): Promise<void>
+    install(options: installation.Options): Promise<void>
 
-        install(options: installation.Options): Promise<void>
+    template(options: template.Options): Promise<string>
 
-        template(options: template.Options): Promise<string>
-    }
+    variables(): dependency.Variables
+  }
 
 }
 
 export namespace installation {
-    export type Options = toa.deployment.installation.Options
+  export type Options = toa.deployment.installation.Options
 }
 
 export namespace template {
-    export type Options = toa.deployment.template.Options
+  export type Options = toa.deployment.template.Options
 }
 
 export type Deployable = toa.deployment.Deployable

package/types/deployment/operator.d.ts

@@ -1,20 +1,23 @@
 // noinspection ES6UnusedImports
 
-import { installation, template } from './deployment'
+import * as _deployment from './deployment'
+import * as _dependency from './dependency'
 
 declare namespace toa.deployment {
 
-    interface Operator {
-        export(path?: string): Promise<string>
+  interface Operator {
+    export(path?: string): Promise<string>
 
-        prepare(path?: string): Promise<string>
+    prepare(path?: string): Promise<string>
 
-        build(): Promise<void>
+    build(): Promise<void>
 
-        install(options?: installation.Options): Promise<void>
+    install(options?: _deployment.installation.Options): Promise<void>
 
-        template(options?: template.Options): Promise<string>
-    }
+    template(options?: _deployment.template.Options): Promise<string>
+
+    variables(): _dependency.dependency.Variables
+  }
 
 }