hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/executables/nodes_to_deploy_spec.rb

@@ -0,0 +1,283 @@
+describe 'nodes_to_deploy executable' do
+
+  # Setup a platform for nodes_to_deploy tests
+  #
+  # Parameters::
+  # * *additional_platforms_content* (String): Additional platforms content to be added [default = '']
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_nodes_to_deploy(additional_platforms_content: '')
+    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }, false, additional_platforms_content) do |repository|
+      yield repository
+    end
+  end
+
+  it 'returns all nodes by default' do
+    with_test_platform_for_nodes_to_deploy do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef1", ''],
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+      expect(stderr).to match /\[ node1 \] - No deployment schedule defined./
+      expect(stderr).to match /\[ node2 \] - No deployment schedule defined./
+    end
+  end
+
+  it 'can filter nodes' do
+    with_test_platform_for_nodes_to_deploy do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy', '--node', 'node2'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node2
+      EOS
+      expect(stderr).not_to match /\[ node1 \] - No deployment schedule defined./
+      expect(stderr).to match /\[ node2 \] - No deployment schedule defined./
+    end
+  end
+
+  it 'does not return nodes that have no impact' do
+    with_test_platform_for_nodes_to_deploy do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef1", ''],
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+      EOS
+    end
+  end
+
+  it 'considers nodes having no repository info in their logs to be deployed' do
+    with_test_platform_for_nodes_to_deploy do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "exit_status: 0\n", ''],
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+      EOS
+    end
+  end
+
+  it 'ignores impacts if asked' do
+    with_test_platform_for_nodes_to_deploy do
+      exit_code, stdout, stderr = run 'nodes_to_deploy', '--ignore-deployed-info'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+    end
+  end
+
+  it 'does not return nodes that are outside the schedule' do
+    with_test_platform_for_nodes_to_deploy(additional_platforms_content: '
+      for_nodes(\'node1\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 120, duration: 60)) }
+      for_nodes(\'node2\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 60, duration: 120)) }
+    ') do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node2
+      EOS
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'does not return nodes that are outside the schedule when using a different deployment time' do
+    with_test_platform_for_nodes_to_deploy(additional_platforms_content: '
+      for_nodes(\'node1\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 120, duration: 60)) }
+      for_nodes(\'node2\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 60, duration: 120)) }
+    ') do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef1", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      # 90 seconds before now, the schedule should match only node1
+      exit_code, stdout, stderr = run 'nodes_to_deploy', '--deployment-time', (Time.now.utc - 90).strftime('%F %T')
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+      EOS
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'returns nodes that are outside the schedule when ignoring the schedule' do
+    with_test_platform_for_nodes_to_deploy(additional_platforms_content: '
+      for_nodes(\'node1\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 120, duration: 60)) }
+      for_nodes(\'node2\') { deployment_schedule(IceCube::Schedule.new(Time.now.utc - 60, duration: 120)) }
+    ') do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef1", ''],
+          'node2' => [0, "repo_name_0: platform\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform', from_commit: 'abcdef2', to_commit: 'master') { [%w[node1 node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy', '--ignore-schedule'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'considers impacts from several repositories' do
+    with_test_platforms(
+      'platform1' => { nodes: { 'node1' => {}, 'node2' => {} } },
+      'platform2' => { nodes: {} }
+    ) do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "repo_name_0: platform1\nexit_status: 0\ncommit_id_0: abcdef1", ''],
+          'node2' => [0, "repo_name_0: platform2\nexit_status: 0\ncommit_id_0: abcdef2", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform1', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform2', from_commit: 'abcdef2', to_commit: 'master') { [%w[node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+    end
+  end
+
+  it 'considers impacts from several repositories for the same node as different services for different platforms might be deployed' do
+    with_test_platforms(
+      'platform1' => { nodes: { 'node1' => {}, 'node2' => {} } },
+      'platform2' => { nodes: {} },
+      'platform3' => { nodes: {} }
+    ) do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "exit_status: 0\nrepo_name_0: platform1\ncommit_id_0: abcdef1\nrepo_name_1: platform2\ncommit_id_1: 1234567", ''],
+          'node2' => [0, "exit_status: 0\nrepo_name_0: platform2\ncommit_id_0: abcdef2\nrepo_name_1: platform3\ncommit_id_1: 2345678", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform1', from_commit: 'abcdef1', to_commit: 'master') { [%w[], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform2', from_commit: '1234567', to_commit: 'master') { [%w[node1], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform2', from_commit: 'abcdef2', to_commit: 'master') { [%w[], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform3', from_commit: '2345678', to_commit: 'master') { [%w[node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+    end
+  end
+
+  it 'considers impacts from several repositories for the same node but does not query diffs for the nodes we already know need deployment' do
+    with_test_platforms(
+      'platform1' => { nodes: { 'node1' => {}, 'node2' => {} } },
+      'platform2' => { nodes: {} },
+      'platform3' => { nodes: {} }
+    ) do
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          'node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" },
+          'node2' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" }
+        )
+        {
+          'node1' => [0, "exit_status: 0\nrepo_name_0: platform1\ncommit_id_0: abcdef1\nrepo_name_1: platform2\ncommit_id_1: 1234567", ''],
+          'node2' => [0, "exit_status: 0\nrepo_name_0: platform2\ncommit_id_0: abcdef2\nrepo_name_1: platform3\ncommit_id_1: 2345678", '']
+        }
+      end])
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform1', from_commit: 'abcdef1', to_commit: 'master') { [%w[node1], [], [], false] }
+      expect(test_nodes_handler).to receive(:impacted_nodes_from_git_diff).with('platform2', from_commit: 'abcdef2', to_commit: 'master') { [%w[node2], [], [], false] }
+      exit_code, stdout, stderr = run 'nodes_to_deploy'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        ===== Nodes to deploy =====
+        node1
+        node2
+      EOS
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/actions_executor_spec.rb

@@ -0,0 +1,28 @@
+describe 'executables\' Actions Executor options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_actions_executor_options
+    with_test_platform({ nodes: { 'node' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  it 'drives the maximum number of threads' do
+    with_test_platform_for_actions_executor_options do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(test_actions_executor.max_threads).to eq 5
+        {}
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node', '--command', 'echo Hello', '--max-threads', '5'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/cmd_runner_spec.rb

@@ -0,0 +1,28 @@
+describe 'executables\' Cmd Runner options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_cmd_runner_options
+    with_test_platform({ nodes: { 'node' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  it 'displays commands instead of running them' do
+    with_test_platform_for_cmd_runner_options do
+      expect_actions_executor_runs([proc do
+        expect(test_cmd_runner.dry_run).to eq true
+        {}
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node', '--command', 'echo Hello', '--show-commands'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/common_spec.rb

@@ -0,0 +1,67 @@
+describe 'executables\' common options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_common_options
+    with_test_platform(
+      {
+        nodes: { 'node1' => { meta: { host_ip: '192.168.42.42' }, services: ['node1_service'] } },
+        deployable_services: %w[node1_service]
+      },
+      true
+    ) do |repository|
+      yield repository
+    end
+  end
+
+  # List of executables for which we test the common options, along with options to try that should do nothing
+  {
+    'check-node' => ['--node', 'node1', '--show-commands', '--ssh-no-control-master'],
+    'deploy' => ['--node', 'node1', '--show-commands', '--why-run', '--ssh-no-control-master'],
+    'dump_nodes_json' => ['--help'],
+    'free_ips' => [],
+    'free_veids' => [],
+    'last_deploys' => ['--node', 'node1', '--show-commands', '--ssh-no-control-master'],
+    'report' => ['--node', 'node1', '--format', 'stdout'],
+    'setup' => ['--help'],
+    'ssh_config' => [],
+    'run' => ['--node', 'node1', '--show-commands', '--interactive', '--ssh-no-control-master'],
+    'test' => ['--help']
+    # TODO: Add topograph in the tests suite
+    # 'topograph' => ['--from', '--node node1', '--to', '--node node1', '--skip-run', '--output', 'graphviz:graph.gv'],
+  }.each do |executable, default_options|
+
+    context "checking common options for #{executable}" do
+
+      it 'displays its help' do
+        with_test_platform_for_common_options do
+          exit_code, stdout, stderr = run executable, '--help'
+          expect(exit_code).to eq 0
+          expect(stdout).to match /Usage: .*#{executable}/
+          expect(stderr).to eq ''
+        end
+      end
+
+      it 'accepts the debug mode switch' do
+        with_test_platform_for_common_options do
+          exit_code, stdout, stderr = run executable, *(['--debug'] + default_options)
+          expect(exit_code).to eq 0
+          expect(stderr).to eq ''
+        end
+      end
+
+      it 'fails in case of an unknown option' do
+        with_test_platform_for_common_options do
+          expect { run executable, '--invalid_option' }.to raise_error(RuntimeError, 'invalid option: --invalid_option')
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/deployer_spec.rb

@@ -0,0 +1,251 @@
+describe 'executables\' Deployer options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_deployer_options
+    with_test_platform({ nodes: { 'node' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  # Mock calls being made to a Thycotic SOAP API using Savon
+  #
+  # Parameters::
+  # * *url* (String): Mocked URL
+  # * *secret_id* (String): The mocked secret ID
+  # * *mocked_secrets_file* (String or nil): The mocked secrets file stored in Thycotic, or nil to mock a missing secret
+  # * *user* (String or nil): The user to be expected, or nil if it should be read from netrc [default: nil]
+  # * *password* (String or nil): The password to be expected, or nil if it should be read from netrc [default: nil]
+  def mock_thycotic_file_download_on(url, secret_id, mocked_secrets_file, user: nil, password: nil)
+    if user.nil?
+      user = 'thycotic_user_from_netrc'
+      password = 'thycotic_password_from_netrc'
+      expect(HybridPlatformsConductor::Credentials).to receive(:with_credentials_for) do |id, _logger, _logger_stderr, url: nil, &client_code|
+        expect(id).to eq :thycotic
+        expect(url).to eq url
+        client_code.call user, password
+      end
+    end
+    # Mock the Savon calls
+    mocked_savon_client = double 'Mocked Savon client'
+    expect(Savon).to receive(:client) do |params|
+      expect(params[:wsdl]).to eq "#{url}/webservices/SSWebservice.asmx?wsdl"
+      expect(params[:ssl_verify_mode]).to eq :none
+      mocked_savon_client
+    end
+    expect(mocked_savon_client).to receive(:call).with(
+      :authenticate,
+      message: {
+        username: user,
+        password: password,
+        domain: 'thycotic_auth_domain'
+      }
+    ) do
+      { authenticate_response: { authenticate_result: { token: 'soap_token' } } }
+    end
+    expect(mocked_savon_client).to receive(:call).with(
+      :get_secret,
+      message: {
+        token: 'soap_token',
+        secretId: secret_id
+      }
+    ) do
+      {
+        get_secret_response: {
+          get_secret_result:
+            if mocked_secrets_file
+              { secret: { items: { secret_item: { id: '4242' } } } }
+            else
+              { errors: { string: 'Access Denied'}, secret_error: { error_code: 'LOAD', error_message: 'Access Denied', allows_response: false } }
+            end
+        }
+      }
+    end
+    if mocked_secrets_file
+      expect(mocked_savon_client).to receive(:call).with(
+        :download_file_attachment_by_item_id,
+        message: {
+          token: 'soap_token',
+          secretId: secret_id,
+          secretItemId: '4242'
+        }
+      ) do
+        {
+          download_file_attachment_by_item_id_response: {
+            download_file_attachment_by_item_id_result: {
+              file_attachment: Base64.encode64(mocked_secrets_file)
+            }
+          }
+        }
+      end
+    end
+    ENV['hpc_domain_for_thycotic'] = 'thycotic_auth_domain'
+  end
+
+  it 'gets secrets from a file' do
+    with_test_platform_for_deployer_options do |repository|
+      secrets_file = "#{repository}/my_secrets.json"
+      File.write(secrets_file, '{ "secret_name": "secret_value" }')
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.secrets).to eq [{ 'secret_name' => 'secret_value' }]
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--secrets', secrets_file
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'gets secrets from several files' do
+    with_test_platform_for_deployer_options do |repository|
+      secrets_file1 = "#{repository}/my_secrets1.json"
+      File.write(secrets_file1, '{ "secret1": "value1" }')
+      secrets_file2 = "#{repository}/my_secrets2.json"
+      File.write(secrets_file2, '{ "secret2": "value2" }')
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.secrets).to eq [{ 'secret1' => 'value1' }, { 'secret2' => 'value2' }]
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--secrets', secrets_file1, '--secrets', secrets_file2
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails to get secrets from a missing file' do
+    with_test_platform_for_deployer_options do
+      expect do
+        run 'deploy', '--node', 'node', '--secrets', 'unknown_file.json'
+      end.to raise_error 'Missing secret file: unknown_file.json'
+    end
+  end
+
+  it 'gets secrets from a Thycotic Secret Server' do
+    with_test_platform_for_deployer_options do
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.secrets).to eq [{ 'secret_name' => 'secret_value' }]
+        {}
+      end
+      mock_thycotic_file_download_on('https://my_thycotic.domain.com/SecretServer', '1107', '{ "secret_name": "secret_value" }')
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--secrets', 'https://my_thycotic.domain.com/SecretServer:1107'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'gets secrets from a Thycotic Secret Server using env variables' do
+    with_test_platform_for_deployer_options do
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.secrets).to eq [{ 'secret_name' => 'secret_value' }]
+        {}
+      end
+      mock_thycotic_file_download_on(
+        'https://my_thycotic.domain.com/SecretServer',
+        '1107',
+        '{ "secret_name": "secret_value" }',
+        user: 'thycotic_user_from_env',
+        password: 'thycotic_password_from_env'
+      )
+      ENV['hpc_user_for_thycotic'] = 'thycotic_user_from_env'
+      ENV['hpc_password_for_thycotic'] = 'thycotic_password_from_env'
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--secrets', 'https://my_thycotic.domain.com/SecretServer:1107'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'gets secrets from several Thycotic Secret Servers and files' do
+    with_test_platform_for_deployer_options do |repository|
+      secrets_file1 = "#{repository}/my_secrets1.json"
+      File.write(secrets_file1, '{ "secret1": "value1" }')
+      secrets_file3 = "#{repository}/my_secrets3.json"
+      File.write(secrets_file3, '{ "secret3": "value3" }')
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.secrets).to eq [
+          { 'secret1' => 'value1' },
+          { 'secret2' => 'value2' },
+          { 'secret3' => 'value3' },
+          { 'secret4' => 'value4' }
+        ]
+        {}
+      end
+      mock_thycotic_file_download_on('https://my_thycotic2.domain.com/SecretServer', '110702', '{ "secret2": "value2" }')
+      mock_thycotic_file_download_on('https://my_thycotic4.domain.com/SecretServer', '110704', '{ "secret4": "value4" }')
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node',
+        '--secrets', secrets_file1,
+        '--secrets', 'https://my_thycotic2.domain.com/SecretServer:110702',
+        '--secrets', secrets_file3,
+        '--secrets', 'https://my_thycotic4.domain.com/SecretServer:110704'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails to get secrets from a missing Thycotic Secret Server' do
+    with_test_platform_for_deployer_options do
+      mock_thycotic_file_download_on('https://my_thycotic.domain.com/SecretServer', '1107', nil)
+      expect do
+        run 'deploy', '--node', 'node', '--secrets', 'https://my_thycotic.domain.com/SecretServer:1107'
+      end.to raise_error 'Unable to fetch secret file ID https://my_thycotic.domain.com/SecretServer:1107'
+    end
+  end
+
+  it 'uses parallel mode' do
+    with_test_platform_for_deployer_options do |repository|
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.concurrent_execution).to eq true
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--parallel'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'uses why-run' do
+    with_test_platform_for_deployer_options do |repository|
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.use_why_run).to eq true
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--why-run'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'uses timeout with why-run' do
+    with_test_platform_for_deployer_options do |repository|
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.timeout).to eq 5
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--why-run', '--timeout', '5'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails to use timeout without why-run' do
+    with_test_platform_for_deployer_options do |repository|
+      expect { run 'deploy', '--node', 'node', '--timeout', '5' }.to raise_error(RuntimeError, 'Can\'t have a timeout unless why-run mode. Please don\'t use --timeout without --why-run.')
+    end
+  end
+
+  it 'uses retries on errors' do
+    with_test_platform_for_deployer_options do |repository|
+      expect(test_deployer).to receive(:deploy_on).with(['node']) do
+        expect(test_deployer.nbr_retries_on_error).to eq 42
+        {}
+      end
+      exit_code, stdout, stderr = run 'deploy', '--node', 'node', '--retries-on-error', '42'
+      expect(exit_code).to eq 0
+      expect(stderr).to eq ''
+    end
+  end
+
+end