central-cli 0.6.3

data/lib/central/machine/vagrant/node_destroyer.rb

@@ -0,0 +1,38 @@
+require 'fileutils'
+
+module Central
+  module Machine
+    module Vagrant
+      class NodeDestroyer
+        include RandomName
+
+        attr_reader :client, :api_client
+
+        # @param [Central::Client] api_client Central api client
+        def initialize(api_client)
+          @api_client = api_client
+        end
+
+        def run!(stack, name)
+          vagrant_path = "#{Dir.home}/.central/#{stack}/#{name}"
+          Dir.chdir(vagrant_path) do
+            ShellSpinner "Terminating Vagrant machine #{name.colorize(:cyan)} " do
+              Open3.popen2('vagrant destroy -f') do |_stdin, output, wait|
+                while o = output.gets
+                  puts o if ENV['DEBUG']
+                end
+                FileUtils.remove_entry_secure(vagrant_path) if wait.value == 0
+              end
+            end
+          end
+          node = api_client.get("stacks/#{stack}/nodes")['nodes'].find { |n| n['name'] == name }
+          if node
+            ShellSpinner "Removing node #{name.colorize(:cyan)} from stack #{stack.colorize(:cyan)} " do
+              api_client.delete("stacks/#{stack}/nodes/#{name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/central/machine/vagrant/node_provisioner.rb

@@ -0,0 +1,68 @@
+require 'fileutils'
+require 'erb'
+require 'open3'
+require 'shell-spinner'
+
+module Central
+  module Machine
+    module Vagrant
+      class NodeProvisioner
+        include RandomName
+
+        attr_reader :client, :api_client
+
+        # @param [Central::Client] api_client Central api client
+        def initialize(api_client)
+          @api_client = api_client
+        end
+
+        def run!(opts)
+          stack = opts[:stack]
+          name = opts[:name] || generate_name
+          version = opts[:version]
+          vagrant_path = "#{Dir.home}/.central/#{stack}/#{name}"
+          FileUtils.mkdir_p(vagrant_path)
+
+          template = File.join(__dir__, '/Vagrantfile.node.rb.erb')
+          cloudinit_template = File.join(__dir__, '/cloudinit.yml')
+          vars = {
+            name: name,
+            version: version,
+            memory: opts[:memory] || 1024,
+            master_uri: opts[:master_uri],
+            stack_token: opts[:stack_token],
+            cloudinit: "#{vagrant_path}/cloudinit.yml"
+          }
+          vagrant_data = erb(File.read(template), vars)
+          cloudinit = erb(File.read(cloudinit_template), vars)
+          File.write("#{vagrant_path}/Vagrantfile", vagrant_data)
+          File.write("#{vagrant_path}/cloudinit.yml", cloudinit)
+          Dir.chdir(vagrant_path) do
+            ShellSpinner "Creating Vagrant machine #{name.colorize(:cyan)} " do
+              Open3.popen2('vagrant box update && vagrant up') do |_stdin, output, _wait|
+                while o = output.gets
+                  print o if ENV['DEBUG']
+                end
+              end
+            end
+            ShellSpinner "Waiting for node #{name.colorize(:cyan)} join to stack #{stack.colorize(:cyan)} " do
+              sleep 1 until node_exists_in_stack?(stack, name)
+            end
+          end
+        end
+
+        def generate_name
+          "#{super}-#{rand(1..99)}"
+        end
+
+        def erb(template, vars)
+          ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
+        end
+
+        def node_exists_in_stack?(stack, name)
+          api_client.get("stacks/#{stack}/nodes")['nodes'].find { |n| n['name'] == name }
+        end
+      end
+    end
+  end
+end

data/lib/central/scripts/completer

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require 'pathname'
+require 'yaml'
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$LOAD_PATH.unshift File.expand_path('../../lib', bin_file)
+
+require_relative '../client'
+require_relative '../cli/common'
+
+class Helper
+  include Central::Cli::Common
+
+  def client
+    token = require_token
+    super(token)
+  end
+
+  def stacks
+    client.get('stacks')['stacks'].map { |stack| stack['id'] }
+  rescue
+    []
+  end
+
+  def nodes
+    client.get("stacks/#{current_stack}/nodes")['nodes'].map { |node| node['name'] }
+  rescue
+    []
+  end
+
+  def services
+    services = client.get("stacks/#{current_stack}/services")['services']
+    results = []
+    results.push services.map { |s| s['name'] }
+
+    results
+  rescue
+    []
+  end
+
+  def containers
+    results = []
+    client.get("stacks/#{current_stack}/services")['services'].each do |service|
+      containers = client.get("services/#{service['id']}/containers")['containers']
+      results.push(containers.map { |c| c['name'] })
+      results.push(containers.map { |c| c['id'] })
+    end
+    results
+  rescue
+    []
+  end
+
+  def yml_services
+    if File.exist?('central.yml')
+      services = YAML.load(File.read('central.yml'))
+      services.keys
+    end
+  rescue
+    []
+  end
+
+  def master_names
+    config_file = File.expand_path('~/.central_client.json')
+    if File.exist?(config_file)
+      config = JSON.parse(File.read(config_file))
+      return config['servers'].map { |s| s['name'] }
+    end
+  rescue
+    []
+  end
+end
+
+helper = Helper.new
+
+words = ARGV
+words.delete_at(0)
+
+completion = []
+completion.push %w(app deploy forgot-password master node stack service container vpn external-registry registry login logout whoami) if words.size < 2
+if words.size > 0
+  case words[0]
+  when 'stack'
+    completion.clear
+    sub_commands = %w(add-user audit-log create current list user remove show use)
+    if words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push helper.stacks
+    else
+      completion.push sub_commands
+    end
+  when 'node'
+    completion.clear
+    sub_commands = %w(list show remove vagrant digitalocean azure aws)
+    if words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push helper.nodes
+    else
+      completion.push sub_commands
+    end
+  when 'master'
+    completion.clear
+    sub_commands = %w(list use vagrant digitalocean azure aws users)
+    if words[1] && words[1] == 'use'
+      completion.push helper.master_names
+    elsif words[1] && words[1] == 'users'
+      users_sub_commands = %(invite list role)
+      completion.push users_sub_commands
+    elsif words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push %w(create)
+    else
+      completion.push sub_commands
+    end
+  when 'service'
+    completion.clear
+    sub_commands = %w(containers create delete deploy list logs restart
+                      scale show start stats stop update monitor env
+                      secret link unlink)
+    if words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push helper.services
+    else
+      completion.push sub_commands
+    end
+  when 'container'
+    completion.clear
+    sub_commands = %w(exec)
+    if words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push helper.containers
+    else
+      completion.push sub_commands
+    end
+  when 'vpn'
+    completion.clear
+    completion.push %w(config create delete)
+  when 'external-registry'
+    completion.clear
+    completion.push %w(add list delete)
+  when 'app'
+    completion.clear
+    sub_commands = %w(init build deploy start stop remove rm ps list
+                      logs monitor show)
+    if words[1]
+      completion.push(sub_commands) unless sub_commands.include?(words[1])
+      completion.push helper.yml_services
+    else
+      completion.push sub_commands
+    end
+  end
+end
+
+puts completion

data/lib/central/scripts/init

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+_central_complete() {
+  COMPREPLY=()
+  DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local completions="$(${DIR}/completer ${COMP_WORDS[*]})"
+  COMPREPLY=( $(compgen -W "$completions" -- "$word") )
+}
+
+complete -F _central_complete central

data/spec/central/cli/app/common_spec.rb

@@ -0,0 +1,150 @@
+require_relative '../../../spec_helper'
+require 'central/cli/apps/common'
+
+describe Central::Cli::Apps::Common do
+  include ClientHelpers
+  include FixturesHelpers
+
+  let(:subject) do
+    Class.new { include Central::Cli::Apps::Common }.new
+  end
+
+  let(:central_yml) do
+    fixture('central.yml')
+  end
+
+  let(:docker_compose_yml) do
+    fixture('docker-compose.yml')
+  end
+
+  let(:mysql_yml) do
+    fixture('mysql.yml')
+  end
+
+  let(:services) do
+    {
+      'wordpress' => {
+        'image' => 'wordpress:4.1',
+        'ports' => ['80:80']
+      }
+    }
+  end
+
+  describe '#parse_services' do
+    it 'returns services from given YAML file' do
+      allow(File).to receive(:read).with("#{Dir.getwd}/central.yml").and_return(central_yml)
+      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(docker_compose_yml)
+      services = subject.parse_services('central.yml')
+      expect(services['wordpress']).not_to be_nil
+    end
+
+    it 'raises error if extended service is not found from base file' do
+      allow(File).to receive(:read).with("#{Dir.getwd}/central.yml").and_return(central_yml)
+      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(mysql_yml)
+
+      expect do
+        subject.parse_services('central.yml')
+      end.to raise_error(SystemExit)
+    end
+  end
+
+  describe '#normalize_env_vars' do
+    it 'converts env hash to array' do
+      opts = {
+        'environment' => {
+          'FOO' => 'bar',
+          'BAR' => 'baz'
+        }
+      }
+      subject.normalize_env_vars(opts)
+      env = opts['environment']
+      expect(env).to include('FOO=bar')
+      expect(env).to include('BAR=baz')
+    end
+
+    it 'does nothing to env array' do
+      opts = {
+        'environment' => [
+          'FOO=bar', 'BAR=baz'
+        ]
+      }
+      subject.normalize_env_vars(opts)
+      env = opts['environment']
+      expect(env).to include('FOO=bar')
+      expect(env).to include('BAR=baz')
+    end
+  end
+
+  describe '#extend_env_vars' do
+    it 'inherites env vars from upper level' do
+      from = ['FOO=bar']
+      to = nil
+      env_vars = subject.extend_env_vars(from, to)
+      expect(env_vars).to eq(['FOO=bar'])
+    end
+
+    it 'overrides values' do
+      from = ['FOO=bar']
+      to = ['FOO=baz']
+      env_vars = subject.extend_env_vars(from, to)
+      expect(env_vars).to eq(['FOO=baz'])
+    end
+
+    it 'combines variables' do
+      from = ['FOO=bar']
+      to = ['BAR=baz']
+      env_vars = subject.extend_env_vars(from, to)
+      expect(env_vars).to eq(['BAR=baz', 'FOO=bar'])
+    end
+  end
+
+  describe '#extend_secrets' do
+    it 'inherites secrets from upper level' do
+      secret = {
+        'secret' => 'CUSTOMER_DB_PASSWORD',
+        'name' => 'MYSQL_PASSWORD',
+        'type' => 'env'
+      }
+      from = [secret]
+      to = nil
+      secrets = subject.extend_secrets(from, to)
+      expect(secrets).to eq([secret])
+    end
+
+    it 'overrides secrets' do
+      from_secret = {
+        'secret' => 'CUSTOMER_DB_PASSWORD',
+        'name' => 'MYSQL_PASSWORD',
+        'type' => 'env'
+      }
+
+      to_secret = {
+        'secret' => 'CUSTOMER_DB_PASSWORD',
+        'name' => 'MYSQL_ROOT_PASSWORD',
+        'type' => 'env'
+      }
+      from = [from_secret]
+      to = [to_secret]
+      secrets = subject.extend_secrets(from, to)
+      expect(secrets).to eq([to_secret])
+    end
+
+    it 'combines secrets' do
+      from_secret = {
+        'secret' => 'CUSTOMER_DB_PASSWORD',
+        'name' => 'MYSQL_PASSWORD',
+        'type' => 'env'
+      }
+
+      to_secret = {
+        'secret' => 'CUSTOMER_API_TOKEN',
+        'name' => 'API_TOKEN',
+        'type' => 'env'
+      }
+      from = [from_secret]
+      to = [to_secret]
+      secrets = subject.extend_secrets(from, to)
+      expect(secrets).to eq([to_secret, from_secret])
+    end
+  end
+end

data/spec/central/cli/app/deploy_command_spec.rb

@@ -0,0 +1,598 @@
+require_relative '../../../spec_helper'
+require 'central/cli/stack_options'
+require 'central/cli/apps/deploy_command'
+
+describe Central::Cli::Apps::DeployCommand do
+  include FixturesHelpers
+
+  let(:subject) do
+    described_class.new(File.basename($PROGRAM_NAME))
+  end
+
+  let(:settings) do
+    { 'current_server' => 'alias',
+      'servers' => [
+        { 'name' => 'some_master', 'url' => 'some_master' },
+        { 'name' => 'alias', 'url' => 'someurl', 'token' => token }
+      ]
+    }
+  end
+
+  let(:settings_without_api_url) do
+    { 'current_server' => 'alias',
+      'servers' => [
+        { 'name' => 'alias', 'token' => token }
+      ]
+    }
+  end
+
+  let(:settings_without_token) do
+    { 'current_server' => 'alias',
+      'servers' => [
+        { 'name' => 'alias', 'url' => 'url' }
+      ]
+    }
+  end
+
+  let(:token) do
+    '1234567'
+  end
+
+  let(:docker_compose_yml) do
+    fixture('docker-compose.yml')
+  end
+
+  let(:central_yml) do
+    fixture('central.yml')
+  end
+
+  let(:services) do
+    {
+      'wordpress' => {
+        'image' => 'wordpress:latest',
+        'links' => ['mysql:db'],
+        'ports' => ['80:80'],
+        'instances' => 2,
+        'deploy' => {
+          'strategy' => 'ha'
+        }
+      },
+      'mysql' => {
+        'image' => 'mysql:5.6',
+        'stateful' => true
+      }
+    }
+  end
+
+  let(:client) do
+    double
+  end
+
+  let(:options) do
+    double(prefix: false, file: false, service: nil)
+  end
+
+  let(:env_vars) do
+    ['#comment line', 'TEST_ENV_VAR=test', 'MYSQL_ADMIN_PASSWORD=abcdef']
+  end
+
+  let(:dot_env) do
+    ['TEST_ENV_VAR=test2', '', 'TEST_ENV_VAR2=test3']
+  end
+
+  describe '.run' do
+    before(:each) do
+      allow(subject).to receive(:wait_for_deploy_to_finish).and_return(true)
+    end
+
+    context 'when api_url is nil' do
+      it 'raises error' do
+        allow(subject).to receive(:settings).and_return(settings_without_api_url)
+        expect { subject.run([]) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when token is nil' do
+      it 'raises error' do
+        allow(subject).to receive(:settings).and_return(settings_without_token)
+        expect { subject.run([]) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when api url and token are valid' do
+      before(:each) do
+        allow(subject).to receive(:settings).and_return(settings)
+        allow(File).to receive(:exists?).and_return(true)
+        allow(File).to receive(:read).with("#{Dir.getwd}/central.yml").and_return(central_yml)
+        allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(docker_compose_yml)
+        allow(subject).to receive(:get_service).and_raise(Central::Errors::StandardError.new(404, 'Not Found'))
+        allow(subject).to receive(:create_service).and_return({ 'id' => 'cli/central-test-mysql', 'name' => 'central-test-mysql' }, 'id' => 'cli/central-test-wordpress', 'name' => 'central-test-wordpress')
+        allow(subject).to receive(:current_stack).and_return('1')
+        allow(subject).to receive(:deploy_service).and_return(nil)
+      end
+
+      it 'reads ./central.yml file by default' do
+        allow(subject).to receive(:settings).and_return(settings)
+        expect(File).to receive(:read).with("#{Dir.getwd}/central.yml").and_return(central_yml)
+        subject.run([])
+      end
+
+      it 'reads given yml file' do
+        expect(File).to receive(:read).with("#{Dir.getwd}/custom.yml").and_return(central_yml)
+        subject.run(['--file', 'custom.yml'])
+      end
+
+      it 'uses current directory as service name prefix by default' do
+        current_dir = '/central/tests/stacks'
+        allow(Dir).to receive(:getwd).and_return(current_dir)
+        expect(File).to receive(:basename).with(current_dir).and_return('stacks')
+        subject.run([])
+      end
+
+      context 'when yml file has multiple env files' do
+        it 'merges environment variables correctly' do
+          allow(subject).to receive(:current_dir).and_return('central-test')
+          allow(YAML).to receive(:load).and_return(services)
+          services['wordpress']['environment'] = ['MYSQL_ADMIN_PASSWORD=password']
+          services['wordpress']['env_file'] = %w(/path/to/env_file .env)
+
+          expect(File).to receive(:readlines).with('/path/to/env_file').and_return(env_vars)
+          expect(File).to receive(:readlines).with('.env').and_return(dot_env)
+
+          data = {
+            name: 'central-test-wordpress',
+            image: 'wordpress:latest',
+            env: ['MYSQL_ADMIN_PASSWORD=password', 'TEST_ENV_VAR=test', 'TEST_ENV_VAR2=test3'],
+            container_count: 2,
+            stateful: false,
+            strategy: 'ha',
+            links: [{ name: 'central-test-mysql', alias: 'db' }],
+            ports: [{ container_port: '80', node_port: '80', protocol: 'tcp' }]
+          }
+
+          expect(subject).to receive(:create_service).with('1234567', '1', hash_including(data))
+          subject.run([])
+        end
+      end
+
+      context 'when yml file has one env file' do
+        it 'merges environment variables correctly' do
+          allow(subject).to receive(:current_dir).and_return('central-test')
+          allow(YAML).to receive(:load).and_return(services)
+          services['wordpress']['environment'] = ['MYSQL_ADMIN_PASSWORD=password']
+          services['wordpress']['env_file'] = '/path/to/env_file'
+
+          expect(File).to receive(:readlines).with('/path/to/env_file').and_return(env_vars)
+
+          data = {
+            name: 'central-test-wordpress',
+            image: 'wordpress:latest',
+            env: ['MYSQL_ADMIN_PASSWORD=password', 'TEST_ENV_VAR=test'],
+            container_count: 2,
+            stateful: false,
+            strategy: 'ha',
+            links: [{ name: 'central-test-mysql', alias: 'db' }],
+            ports: [{ container_port: '80', node_port: '80', protocol: 'tcp' }]
+          }
+
+          expect(subject).to receive(:create_service).with('1234567', '1', hash_including(data))
+          subject.run([])
+        end
+      end
+
+      it 'merges external links to links' do
+        allow(subject).to receive(:current_dir).and_return('central-test')
+        allow(YAML).to receive(:load).and_return(services)
+        services['wordpress']['external_links'] = ['loadbalancer:loadbalancer']
+        data = {
+          name: 'central-test-wordpress',
+          image: 'wordpress:latest',
+          env: nil,
+          container_count: 2,
+          stateful: false,
+          strategy: 'ha',
+          links: [{ name: 'central-test-mysql', alias: 'db' }, { name: 'loadbalancer', alias: 'loadbalancer' }],
+          ports: [{ container_port: '80', node_port: '80', protocol: 'tcp' }]
+        }
+
+        expect(subject).to receive(:create_service).with('1234567', '1', hash_including(data))
+        subject.run([])
+      end
+
+      it 'creates mysql service before wordpress' do
+        allow(subject).to receive(:current_dir).and_return('central-test')
+        data = {
+          name: 'central-test-mysql',
+          image: 'mysql:5.6',
+          env: ['MYSQL_ROOT_PASSWORD=central-test_secret'],
+          container_count: nil,
+          stateful: true
+        }
+        expect(subject).to receive(:create_service).with('1234567', '1', hash_including(data))
+
+        subject.run([])
+      end
+
+      it 'creates wordpress service' do
+        allow(subject).to receive(:current_dir).and_return('central-test')
+
+        data = {
+          name: 'central-test-wordpress',
+          image: 'wordpress:4.1',
+          env: ['WORDPRESS_DB_PASSWORD=central-test_secret'],
+          container_count: 2,
+          stateful: true,
+          strategy: 'ha',
+          links: [{ name: 'central-test-mysql', alias: 'mysql' }],
+          ports: [{ container_port: '80', node_port: '80', protocol: 'tcp' }]
+        }
+        expect(subject).to receive(:create_service).with('1234567', '1', hash_including(data))
+
+        subject.run([])
+      end
+
+      it 'deploys services' do
+        allow(subject).to receive(:current_dir).and_return('central-test')
+        expect(subject).to receive(:deploy_service).with('1234567', 'central-test-mysql', {})
+        expect(subject).to receive(:deploy_service).with('1234567', 'central-test-wordpress', {})
+        subject.run([])
+      end
+
+      context 'when giving service option' do
+        it 'deploys only given services' do
+          allow(subject).to receive(:current_dir).and_return('central-test')
+          allow(subject).to receive(:deploy_services).and_return({})
+          expect(subject).to receive(:create).once.with('wordpress', anything).and_return({})
+          expect(subject).not_to receive(:create).with('mysql', services['mysql'])
+
+          subject.run(['wordpress'])
+        end
+      end
+    end
+  end
+
+  describe '#parse_data' do
+    context 'volumes' do
+      it 'returns volumes if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'volumes' => [
+            'mongodb-1'
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:volumes]).to eq(data['volumes'])
+      end
+
+      it 'returns empty volumes if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:volumes]).to eq([])
+      end
+    end
+
+    context 'volumes_from' do
+      it 'returns volumes_from if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'volumes_from' => [
+            'mongodb-1'
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:volumes_from]).to eq(data['volumes_from'])
+      end
+
+      it 'returns empty volumes_from if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:volumes_from]).to eq([])
+      end
+    end
+
+    context 'command' do
+      it 'returns cmd array if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'command' => 'ls -la'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:cmd]).to eq(data['command'].split(' '))
+      end
+
+      it 'does not return cmd if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result.key?(:cmd)).to be_falsey
+      end
+    end
+
+    context 'affinity' do
+      it 'returns affinity if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'affinity' => [
+            'label==az=b'
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:affinity]).to eq(data['affinity'])
+      end
+
+      it 'returns affinity as empty array if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result.key?(:affinity)).to be_truthy
+        expect(result[:affinity]).to eq([])
+      end
+    end
+
+    context 'user' do
+      it 'returns user if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'user' => 'user'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:user]).to eq('user')
+      end
+
+      it 'does not return user if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result.key?(:user)).to be_falsey
+      end
+    end
+
+    context 'stateful' do
+      it 'returns stateful if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'stateful' => true
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:stateful]).to eq(true)
+      end
+
+      it 'returns stateful as false if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:stateful]).to eq(false)
+      end
+    end
+
+    context 'privileged' do
+      it 'returns privileged if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'privileged' => false
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:privileged]).to eq(false)
+      end
+
+      it 'does not return privileged if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:privileged]).to be_nil
+      end
+    end
+
+    context 'cap_add' do
+      it 'returns cap_drop if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'cap_add' => [
+            'NET_ADMIN'
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:cap_add]).to eq(data['cap_add'])
+      end
+
+      it 'does not return cap_add if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:cap_add]).to be_nil
+      end
+    end
+
+    context 'cap_drop' do
+      it 'returns cap_drop if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'cap_drop' => [
+            'NET_ADMIN'
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:cap_drop]).to eq(data['cap_drop'])
+      end
+
+      it 'does not return cap_drop if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:cap_drop]).to be_nil
+      end
+    end
+
+    context 'net' do
+      it 'returns net if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'net' => 'host'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:net]).to eq('host')
+      end
+
+      it 'does not return pid if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:net]).to be_nil
+      end
+    end
+
+    context 'pid' do
+      it 'returns pid if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'pid' => 'host'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:pid]).to eq('host')
+      end
+
+      it 'does not return pid if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:pid]).to be_nil
+      end
+    end
+
+    context 'log_driver' do
+      it 'returns log_driver if set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'log_driver' => 'syslog'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:log_driver]).to eq('syslog')
+      end
+
+      it 'does not return log_driver if not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:log_driver]).to be_nil
+      end
+    end
+
+    context 'log_opt' do
+      it 'returns log_opts hash if log_opt is set' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'log_driver' => 'fluentd',
+          'log_opt' => {
+            'fluentd-address' => '192.168.99.1:24224',
+            'fluentd-tag' => 'docker.{{.Name}}'
+          }
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:log_opts]).to eq(data['log_opt'])
+      end
+
+      it 'does not return log_opts if log_opt is not set' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:log_opts]).to be_nil
+      end
+    end
+
+    context 'deploy_opts' do
+      it 'returns deploy_opts if deploy.wait_for_port is defined' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'deploy' => {
+            'wait_for_port' => '8080'
+          }
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:deploy_opts][:wait_for_port]).to eq('8080')
+      end
+
+      it 'returns deploy_opts if deploy.min_health is defined' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'deploy' => {
+            'min_health' => '0.5'
+          }
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:deploy_opts][:min_health]).to eq('0.5')
+      end
+
+      it 'sets strategy if deploy.strategy is defined' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'deploy' => {
+            'strategy' => 'daemon'
+          }
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:strategy]).to eq('daemon')
+      end
+
+      it 'does not return deploy_opts if no deploy options are defined' do
+        data = {
+          'image' => 'foo/bar:latest'
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:deploy_opts]).to be_nil
+      end
+    end
+
+    context 'hooks' do
+      it 'returns hooks hash if defined' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'hooks' => {
+            'post_start' => []
+          }
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:hooks]).to eq(data['hooks'])
+      end
+
+      it 'does returns empty hook hash if not defined' do
+        data = { 'image' => 'foo/bar:latest' }
+        result = subject.send(:parse_data, data)
+        expect(result[:hooks]).to eq({})
+      end
+    end
+
+    context 'secrets' do
+      it 'returns secrets array if defined' do
+        data = {
+          'image' => 'foo/bar:latest',
+          'secrets' => [
+            { 'secret' => 'MYSQL_ADMIN_PASSWORD', 'name' => 'WORDPRESS_DB_PASSWORD', 'type' => 'env' }
+          ]
+        }
+        result = subject.send(:parse_data, data)
+        expect(result[:secrets]).to eq(data['secrets'])
+      end
+
+      it 'does not return secrets if not defined' do
+        data = { 'image' => 'foo/bar:latest' }
+        result = subject.send(:parse_data, data)
+        expect(result[:secrets]).to be_nil
+      end
+    end
+  end
+end