hybrid_platforms_conductor 33.4.0 → 33.7.1

data/spec/hybrid_platforms_conductor_test/api/actions_executor/connectors/ssh/global_helpers_spec.rb

@@ -175,6 +175,16 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'generates a simple config for a node with host_ip and a given SSH port' do
+        with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_port: 666 } } } }) do
+          expect(ssh_config_for('node')).to eq <<~EO_SSH_CONFIG
+            Host hpc.node
+              Hostname 192.168.42.42
+              Port 666
+          EO_SSH_CONFIG
+        end
+      end
+
       it 'generates a simple config for several nodes' do
         with_test_platform(
           {

data/spec/hybrid_platforms_conductor_test/api/actions_executor/connectors/ssh/remote_actions_spec.rb

@@ -13,6 +13,15 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'executes bash commands remotely from a SecretString' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [[%r{.+/ssh hpc\.node /bin/bash <<'HPC_EOF'\nbash_cmd.bash\nHPC_EOF}, proc { [0, 'Bash commands executed on node', ''] }]],
+          expected_stdout: 'Bash commands executed on node'
+        ) do
+          test_connector.remote_bash(SecretString.new('bash_cmd.bash', silenced_str: '__INVALID_BASH__'))
+        end
+      end
+
       it 'executes bash commands remotely with timeout' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
@@ -88,6 +97,25 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'executes really big bash commands remotely using a SecretString' do
+        cmd = "echo #{'1' * 131_060}"
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              %r{.+/hpc_temp_cmds_.+\.sh$},
+              proc do |received_cmd|
+                expect(File.read(received_cmd)).to match(%r{.+/ssh hpc\.node /bin/bash <<'HPC_EOF'\n#{Regexp.escape(cmd)}\nHPC_EOF})
+                [0, 'Bash commands executed on node', '']
+              end
+            ]
+          ],
+          expected_stdout: 'Bash commands executed on node'
+        ) do
+          # Use an argument that exceeds the max arg length limit
+          test_connector.remote_bash(SecretString.new(cmd, silenced_str: '__INVALID_BASH__'))
+        end
+      end
+
       it 'copies files remotely with sudo' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
@@ -153,6 +181,16 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'executes bash commands remotely without Session Exec capabilities using a SecretString' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [[%r{^\{ cat \| .+/ssh hpc\.node -T; \} <<'HPC_EOF'\nbash_cmd.bash\nHPC_EOF$}, proc { [0, 'Bash commands executed on node', ''] }]],
+          expected_stdout: 'Bash commands executed on node',
+          session_exec: false
+        ) do
+          test_connector.remote_bash(SecretString.new('bash_cmd.bash', silenced_str: '__INVALID_BASH__'))
+        end
+      end
+
       it 'copies files remotely without Session Exec capabilities' do
         with_test_platform_for_remote_testing(
           expected_cmds: [

data/spec/hybrid_platforms_conductor_test/api/actions_executor/helpers_spec.rb

@@ -0,0 +1,195 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'when checking helpers' do
+
+    it 'gives access to connectors' do
+      with_test_platform({}) do
+        expect(test_actions_executor.connector(:ssh)).not_to be_nil
+      end
+    end
+
+    it 'returns if a user has privileged access on a node' do
+      with_test_platform({ nodes: { 'node' => {} } }) do
+        test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+        expect(test_actions_executor.privileged_access?('node')).to eq false
+      end
+    end
+
+    it 'returns if a user has privileged access on a node when connecting with root' do
+      with_test_platform({ nodes: { 'node' => {} } }) do
+        test_actions_executor.connector(:ssh).ssh_user = 'root'
+        expect(test_actions_executor.privileged_access?('node')).to eq true
+      end
+    end
+
+    it 'returns if a user has privileged access on a local node' do
+      with_test_platform({ nodes: { 'node' => { meta: { local_node: true } } } }) do
+        with_cmd_runner_mocked [
+          ['whoami', proc { [0, 'test_user', ''] }]
+        ] do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.privileged_access?('node')).to eq false
+        end
+      end
+    end
+
+    it 'returns if a user has privileged access on a local node when local user is root' do
+      with_test_platform({ nodes: { 'node' => { meta: { local_node: true } } } }) do
+        with_cmd_runner_mocked [
+          ['whoami', proc { [0, 'root', ''] }]
+        ] do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.privileged_access?('node')).to eq true
+        end
+      end
+    end
+
+    context 'with connection on a remote node' do
+
+      it 'returns the correct sudo prefix' do
+        with_test_platform({ nodes: { 'node' => {} } }) do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.sudo_prefix('node')).to eq 'sudo -u root '
+        end
+      end
+
+      it 'returns the correct sudo prefix with env forwarding' do
+        with_test_platform({ nodes: { 'node' => {} } }) do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.sudo_prefix('node', forward_env: true)).to eq 'sudo -u root -E '
+        end
+      end
+
+      it 'returns the correct sudo prefix when connecting as root' do
+        with_test_platform({ nodes: { 'node' => {} } }) do
+          test_actions_executor.connector(:ssh).ssh_user = 'root'
+          expect(test_actions_executor.sudo_prefix('node')).to eq ''
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo' do
+        with_test_platform(
+          { nodes: { 'node' => {} } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.sudo_prefix('node')).to eq 'other_sudo --user root '
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo and env forwarding' do
+        with_test_platform(
+          { nodes: { 'node' => {} } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect(test_actions_executor.sudo_prefix('node', forward_env: true)).to eq 'other_sudo --user root -E '
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo when connecting as root' do
+        with_test_platform(
+          { nodes: { 'node' => {} } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          test_actions_executor.connector(:ssh).ssh_user = 'root'
+          expect(test_actions_executor.sudo_prefix('node')).to eq ''
+        end
+      end
+
+    end
+
+    context 'with connection on a local node' do
+
+      it 'returns the correct sudo prefix' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true } } } }) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node')).to eq 'sudo -u root '
+          end
+        end
+      end
+
+      it 'returns the correct sudo prefix with env forwarding' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true } } } }) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node', forward_env: true)).to eq 'sudo -u root -E '
+          end
+        end
+      end
+
+      it 'returns the correct sudo prefix when connecting as root' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true } } } }) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'root', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node')).to eq ''
+          end
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo' do
+        with_test_platform(
+          { nodes: { 'node' => { meta: { local_node: true } } } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node')).to eq 'other_sudo --user root '
+          end
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo and env forwarding' do
+        with_test_platform(
+          { nodes: { 'node' => { meta: { local_node: true } } } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node', forward_env: true)).to eq 'other_sudo --user root -E '
+          end
+        end
+      end
+
+      it 'returns the correct sudo prefix with a different sudo when connecting as root' do
+        with_test_platform(
+          { nodes: { 'node' => { meta: { local_node: true } } } },
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'root', ''] }]
+          ] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect(test_actions_executor.sudo_prefix('node')).to eq ''
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/cmd_runner_spec.rb

@@ -7,6 +7,13 @@ describe HybridPlatformsConductor::CmdRunner do
     end
   end
 
+  it 'runs a simple bash command in a SecretString' do
+    with_repository do |repository|
+      test_cmd_runner.run_cmd SecretString.new("echo TestContent >#{repository}/test_file", silenced_str: '__INVALID_BASH__')
+      expect(File.read("#{repository}/test_file")).to eq "TestContent\n"
+    end
+  end
+
   it 'runs a simple bash command and returns exit code, stdout and stderr correctly' do
     with_repository do
       expect(test_cmd_runner.run_cmd('echo TestStderr 1>&2 ; echo TestStdout')).to eq [0, "TestStdout\n", "TestStderr\n"]
@@ -20,6 +27,13 @@ describe HybridPlatformsConductor::CmdRunner do
     end
   end
 
+  it 'runs a simple bash command and forces usage of bash in a SecretString' do
+    with_repository do
+      # Use set -o pipefail that does not work in /bin/sh
+      expect(test_cmd_runner.run_cmd(SecretString.new('set -o pipefail ; echo TestStderr 1>&2 ; echo TestStdout', silenced_str: '__INVALID_BASH__'), force_bash: true)).to eq [0, "TestStdout\n", "TestStderr\n"]
+    end
+  end
+
   it 'runs a simple bash command and logs stdout and stderr to a file' do
     with_repository do |repository|
       test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout', log_to_file: "#{repository}/test_file"

data/spec/hybrid_platforms_conductor_test/api/config_spec.rb

@@ -29,6 +29,17 @@ describe HybridPlatformsConductor::Config do
     end
   end
 
+  it 'can check if we are in debug mode' do
+    with_platforms(
+      <<~EO_CONFIG
+        os_image :image_1, '/path/to/image_1' if log_debug?
+        os_image :image_2, '/path/to/image_2'
+      EO_CONFIG
+    ) do
+      expect(test_config.known_os_images.sort).to eq %i[image_2].sort
+    end
+  end
+
   it 'returns the tests provisioner correctly' do
     with_platforms 'tests_provisioner :test_provisioner' do
       expect(test_config.tests_provisioner_id).to eq :test_provisioner

data/spec/hybrid_platforms_conductor_test/api/credentials_spec.rb

@@ -15,15 +15,19 @@ describe HybridPlatformsConductor::Credentials do
   # * *resource* (String or nil): The resource for which we query the credentials, or nil if none [default: nil]
   def expect_credentials_to_be(expected_user, expected_password, resource: nil)
     creds = {}
+    password_class = nil
     credential_tester_class.new(logger: logger, logger_stderr: logger, config: test_config).instance_exec do
       with_credentials_for(:test_credential, resource: resource) do |user, password|
+        password_class = password.class
         creds = {
           user: user,
           # We clone the value as for security reasons it is removed when exiting the block
-          password: password.clone
+          password: password&.to_unprotected.clone
         }
       end
     end
+    # Make sure we always return a SecretString for the password
+    expect(password_class).to be SecretString unless password_class == NilClass
     expect(creds).to eq(
       user: expected_user,
       password: expected_password
@@ -64,7 +68,7 @@ describe HybridPlatformsConductor::Credentials do
             leaked_password = password
           end
         end
-        expect(leaked_password).to eq 'gotyou!' * 100
+        expect(leaked_password.to_unprotected).to eq "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       ensure
         ENV.delete('hpc_user_for_test_credential')
         ENV.delete('hpc_password_for_test_credential')
@@ -96,7 +100,7 @@ describe HybridPlatformsConductor::Credentials do
     end
   end
 
-  it 'erases the value of the password taken from netrc' do
+  it 'erases the value of the password taken from netrc after usage' do
     with_platforms '' do
       netrc_data = [['mocked_data']]
       expect(::Netrc).to receive(:read) do
@@ -111,7 +115,7 @@ describe HybridPlatformsConductor::Credentials do
           leaked_password = password
         end
       end
-      expect(leaked_password).to eq 'gotyou!' * 100
+      expect(leaked_password).to eq "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
       expect(netrc_data).to eq [['GotYou!!!' * 100]]
     end
   end

data/spec/hybrid_platforms_conductor_test/api/deployer/log_plugins/remote_fs_spec.rb

@@ -129,6 +129,127 @@ describe HybridPlatformsConductor::Deployer do
         end
       end
 
+      it 'returns actions to save logs on a local node' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true }, services: %w[service1 service2] } } }, additional_config: 'send_logs_to :remote_fs') do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect_services_handler_to_deploy('node' => %w[service1 service2])
+          expect_actions_executor_runs [
+            # First run, we expect the mutex to be setup, and the deployment actions to be run
+            proc do |actions_per_nodes|
+              expect_actions_to_deploy_on(
+                actions_per_nodes,
+                'node',
+                mocked_result: { 'node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'] }
+              )
+            end,
+            # Second run, we expect the mutex to be released
+            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
+            # Third run, we expect logs to be uploaded on the node
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes['node'].size).to eq 3
+              expect(actions_per_nodes['node'][0].keys.sort).to eq %i[ruby remote_bash].sort
+              expect(actions_per_nodes['node'][0][:remote_bash]).to eq 'sudo -u root mkdir -p /var/log/deployments && sudo -u root chmod 600 /var/log/deployments'
+              expect(actions_per_nodes['node'][1].keys.sort).to eq %i[scp].sort
+              expect(actions_per_nodes['node'][1][:scp].delete(:sudo)).to eq true
+              expect(actions_per_nodes['node'][1][:scp].delete(:owner)).to eq 'root'
+              expect(actions_per_nodes['node'][1][:scp].delete(:group)).to eq 'root'
+              expect(actions_per_nodes['node'][1][:scp].size).to eq 1
+              tmp_log_file = actions_per_nodes['node'][1][:scp].first[0]
+              expect(actions_per_nodes['node'][1][:scp].first[1]).to eq '/var/log/deployments'
+              expect(actions_per_nodes['node'][2].keys.sort).to eq %i[ruby remote_bash].sort
+              expect(actions_per_nodes['node'][2][:remote_bash]).to eq "sudo -u root chmod 600 /var/log/deployments/#{File.basename(tmp_log_file)}"
+              # Call the Ruby codes to be tested
+              actions_per_nodes['node'][0][:ruby].call
+              expect(File.exist?(tmp_log_file)).to eq true
+              file_content_regexp = Regexp.new <<~EOREGEXP
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                date: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}
+                user: test_user
+                debug: No
+                services: service1, service2
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EOREGEXP
+              expect(File.read(tmp_log_file)).to match file_content_regexp
+              actions_per_nodes['node'][2][:ruby].call
+              # Check temporary log file gets deleted for security reasons
+              expect(File.exist?(tmp_log_file)).to eq false
+            end
+          ]
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'])
+          end
+        end
+      end
+
+      it 'returns actions to save logs on a local node as root' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true }, services: %w[service1 service2] } } }, additional_config: 'send_logs_to :remote_fs') do
+          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+          expect_services_handler_to_deploy('node' => %w[service1 service2])
+          expect_actions_executor_runs [
+            # First run, we expect the mutex to be setup, and the deployment actions to be run
+            proc do |actions_per_nodes|
+              expect_actions_to_deploy_on(
+                actions_per_nodes,
+                'node',
+                sudo: nil,
+                mocked_result: { 'node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'] }
+              )
+            end,
+            # Second run, we expect the mutex to be released
+            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node', sudo: nil) },
+            # Third run, we expect logs to be uploaded on the node
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes['node'].size).to eq 3
+              expect(actions_per_nodes['node'][0].keys.sort).to eq %i[ruby remote_bash].sort
+              expect(actions_per_nodes['node'][0][:remote_bash]).to eq 'mkdir -p /var/log/deployments && chmod 600 /var/log/deployments'
+              expect(actions_per_nodes['node'][1].keys.sort).to eq %i[scp].sort
+              expect(actions_per_nodes['node'][1][:scp].delete(:sudo)).to eq false
+              expect(actions_per_nodes['node'][1][:scp].delete(:owner)).to eq 'root'
+              expect(actions_per_nodes['node'][1][:scp].delete(:group)).to eq 'root'
+              expect(actions_per_nodes['node'][1][:scp].size).to eq 1
+              tmp_log_file = actions_per_nodes['node'][1][:scp].first[0]
+              expect(actions_per_nodes['node'][1][:scp].first[1]).to eq '/var/log/deployments'
+              expect(actions_per_nodes['node'][2].keys.sort).to eq %i[ruby remote_bash].sort
+              expect(actions_per_nodes['node'][2][:remote_bash]).to eq "chmod 600 /var/log/deployments/#{File.basename(tmp_log_file)}"
+              # Call the Ruby codes to be tested
+              actions_per_nodes['node'][0][:ruby].call
+              expect(File.exist?(tmp_log_file)).to eq true
+              file_content_regexp = Regexp.new <<~EOREGEXP
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                date: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}
+                user: test_user
+                debug: No
+                services: service1, service2
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EOREGEXP
+              expect(File.read(tmp_log_file)).to match file_content_regexp
+              actions_per_nodes['node'][2][:ruby].call
+              # Check temporary log file gets deleted for security reasons
+              expect(File.exist?(tmp_log_file)).to eq false
+            end
+          ]
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'root', ''] }]
+          ] do
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'])
+          end
+        end
+      end
+
       it 'reads logs' do
         with_test_platform_for_remote_fs do
           expect_actions_executor_runs [
@@ -216,6 +337,100 @@ describe HybridPlatformsConductor::Deployer do
         end
       end
 
+      it 'reads logs on a local node' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true }, services: %w[service1 service2] } } }, additional_config: 'send_logs_to :remote_fs') do
+          expect_actions_executor_runs [
+            # Expect the actions to get log files
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes).to eq('node' => [{ remote_bash: 'sudo -u root cat /var/log/deployments/`sudo -u root ls -t /var/log/deployments/ | head -1`' }])
+              { 'node' => [0, <<~EO_STDOUT, ''] }
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                diff_files_0: file1, file2, file3
+                date: 2017-11-23 18:43:01
+                user: test_user
+                debug: Yes
+                services: service1, service2, service3
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EO_STDOUT
+            end
+          ]
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'test_user', ''] }]
+          ] do
+            expect(test_deployer.deployment_info_from('node')).to eq(
+              'node' => {
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  diff_files_0: %w[file1 file2 file3],
+                  date: Time.parse('2017-11-23 18:43:01 UTC'),
+                  debug: true,
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                services: %w[service1 service2 service3],
+                stderr: 'Deploy successful stderr',
+                stdout: 'Deploy successful stdout'
+              }
+            )
+          end
+        end
+      end
+
+      it 'reads logs on a local node as root' do
+        with_test_platform({ nodes: { 'node' => { meta: { local_node: true }, services: %w[service1 service2] } } }, additional_config: 'send_logs_to :remote_fs') do
+          expect_actions_executor_runs [
+            # Expect the actions to get log files
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes).to eq('node' => [{ remote_bash: 'cat /var/log/deployments/`ls -t /var/log/deployments/ | head -1`' }])
+              { 'node' => [0, <<~EO_STDOUT, ''] }
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                diff_files_0: file1, file2, file3
+                date: 2017-11-23 18:43:01
+                user: test_user
+                debug: Yes
+                services: service1, service2, service3
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EO_STDOUT
+            end
+          ]
+          with_cmd_runner_mocked [
+            ['whoami', proc { [0, 'root', ''] }]
+          ] do
+            expect(test_deployer.deployment_info_from('node')).to eq(
+              'node' => {
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  diff_files_0: %w[file1 file2 file3],
+                  date: Time.parse('2017-11-23 18:43:01 UTC'),
+                  debug: true,
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                services: %w[service1 service2 service3],
+                stderr: 'Deploy successful stderr',
+                stdout: 'Deploy successful stdout'
+              }
+            )
+          end
+        end
+      end
+
     end
 
   end