hybrid_platforms_conductor 32.16.3 → 33.0.0

data/spec/hybrid_platforms_conductor_test/api/deployer/deploy_spec.rb

@@ -4,238 +4,213 @@ describe HybridPlatformsConductor::Deployer do
 
     deploy_specs_for(check_mode: false)
 
-    # Expect the test services handler to be called to deploy a given list of services
-    #
-    # Parameters::
-    # * *services* (Hash<String, Array<String> >): List of services to be expected, per node name
-    def expect_services_handler_to_deploy(services)
-      expect(test_services_handler).to receive(:deploy_allowed?).with(
-        services: services,
-        secrets: {},
-        local_environment: false
-      ) do
-        nil
-      end
-      expect(test_services_handler).to receive(:package).with(
-        services: services,
-        secrets: {},
-        local_environment: false
-      )
-      expect(test_services_handler).to receive(:prepare_for_deploy).with(
-        services: services,
-        secrets: {},
-        local_environment: false,
-        why_run: false
-      )
-      services.each do |node, services|
-        expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, services, false) do
-          [{ bash: "echo \"Deploying on #{node}\"" }]
+    context 'checking log plugins usage' do
+
+      # Prepare the test platform with test log plugins
+      #
+      # Parameters::
+      # * *platforms_info* (Hash): The platforms info [default = {}]
+      # * *as_git* (Boolean): As a git repository? [default = false]
+      # * *additional_config* (String): Additional config [default = 'send_logs_to :test_log']
+      def with_test_platform_for_deploy_tests(platforms_info = {}, as_git = false, additional_config = 'send_logs_to :test_log')
+        with_test_platform(platforms_info, false, additional_config) do
+          yield
         end
-        expect(test_services_handler).to receive(:log_info_for).with(node, services) do
-          {
-            repo_name_0: 'platform',
-            commit_id_0: '123456',
-            commit_message_0: "Test commit for #{node}: #{services.join(', ')}"
-          }
+      end
+
+      it 'deploys correct logs information on 1 node' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
+          with_connections_mocked_on ['node'] 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 { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, 'node') },
+              # 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 { |actions_per_nodes| expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Save test logs to node' }]) }
+            ])
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful', ''])
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node',
+                services: %w[service1 service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on 1 node' do
-      with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
-        with_connections_mocked_on ['node'] 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 { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, 'node') },
-            # 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|
-              # Check logs content
-              local_log_file = actions_per_nodes['node'][:scp].first[0]
-              expect(File.exist?(local_log_file)).to eq true
-              expect_logs_to_be(File.read(local_log_file), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node: service1, service2',
-                services: 'service1, service2',
-                exit_status: '0'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, 'node')
-            end
-          ])
-          expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful', ''])
+      it 'deploys correct logs information on several nodes' do
+        with_test_platform_for_deploy_tests({ nodes: {
+          'node1' => { services: %w[service1] },
+          'node2' => { services: %w[service2] }
+        } }, true) do
+          with_connections_mocked_on %w[node1 node2] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect_services_handler_to_deploy(
+              'node1' => %w[service1],
+              'node2' => %w[service2]
+            )
+            expect_actions_executor_runs([
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, %w[node1 node2]) },
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, %w[node1 node2]) },
+              # Third run, we expect logs to be uploaded on the node
+              proc do |actions_per_nodes|
+                expect(actions_per_nodes).to eq(
+                  'node1' => [{ bash: 'echo Save test logs to node1' }],
+                  'node2' => [{ bash: 'echo Save test logs to node2' }]
+                )
+              end
+            ])
+            expect(test_deployer.deploy_on(%w[node1 node2])).to eq(
+              'node1' => [0, 'Deploy successful', ''],
+              'node2' => [0, 'Deploy successful', '']
+            )
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node1',
+                services: %w[service1],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node1: service1',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              },
+              {
+                method: :actions_to_save_logs,
+                node: 'node2',
+                services: %w[service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node2: service2',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on several nodes' do
-      with_test_platform({ nodes: {
-        'node1' => { services: %w[service1] },
-        'node2' => { services: %w[service2] }
-      } }, true) do
-        with_connections_mocked_on %w[node1 node2] do
-          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
-          expect_services_handler_to_deploy(
-            'node1' => %w[service1],
-            'node2' => %w[service2]
-          )
-          expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
-            proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, %w[node1 node2]) },
-            # Second run, we expect the mutex to be released
-            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, %w[node1 node2]) },
-            # Third run, we expect logs to be uploaded on the node
-            proc do |actions_per_nodes|
-              # Check logs content
-              local_log_file1 = actions_per_nodes['node1'][:scp].first[0]
-              expect(File.exist?(local_log_file1)).to eq true
-              expect_logs_to_be(File.read(local_log_file1), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node1: service1',
-                services: 'service1',
-                exit_status: '0'
-              )
-              local_log_file2 = actions_per_nodes['node2'][:scp].first[0]
-              expect(File.exist?(local_log_file2)).to eq true
-              expect_logs_to_be(File.read(local_log_file2), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node2: service2',
-                services: 'service2',
-                exit_status: '0'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, %w[node1 node2])
-            end
-          ])
-          expect(test_deployer.deploy_on(%w[node1 node2])).to eq(
-            'node1' => [0, 'Deploy successful', ''],
-            'node2' => [0, 'Deploy successful', '']
-          )
+      it 'deploys correct logs information on 1 node even when there is a failing deploy' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
+          with_connections_mocked_on ['node'] 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' => [:failed_action, 'Failed deploy stdout', 'Failed deploy 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 { |actions_per_nodes| expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Save test logs to node' }]) }
+            ])
+            expect(test_deployer.deploy_on('node')).to eq('node' => [:failed_action, 'Failed deploy stdout', 'Failed deploy stderr'])
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node',
+                services: %w[service1 service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  user: 'test_user'
+                },
+                exit_status: :failed_action,
+                stdout: 'Failed deploy stdout',
+                stderr: 'Failed deploy stderr'
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on 1 node even when there is a failing deploy' do
-      with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
-        with_connections_mocked_on ['node'] do
-          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
-          expect_services_handler_to_deploy('node' => %w[service1 service2])
+      it 'gets deployment info from log plugins' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }) do |repository|
           expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
+            # Expect the actions to get log files
             proc do |actions_per_nodes|
-              expect_actions_to_deploy_on(
-                actions_per_nodes,
-                'node',
-                mocked_result: { 'node' => [:failed_action, "Failed deploy stdout\n", "Failed deploy stderr\n"] }
-              )
-            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|
-              # Check logs content
-              local_log_file = actions_per_nodes['node'][:scp].first[0]
-              expect(File.exist?(local_log_file)).to eq true
-              expect_logs_to_be(File.read(local_log_file), "Failed deploy stdout\n", 'Failed deploy stderr',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node: service1, service2',
-                services: 'service1, service2',
-                exit_status: 'failed_action'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, 'node')
+              expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Read logs for node' }])
+              { 'node' => [42, 'Log files read stdout', 'Log files read stderr'] }
             end
           ])
-          expect(test_deployer.deploy_on('node')).to eq('node' => [:failed_action, "Failed deploy stdout\n", "Failed deploy stderr\n"])
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: { user: 'test_user' },
+              exit_status: 666,
+              services: %w[unknown],
+              stderr: 'Deployment test stderr',
+              stdout: 'Deployment test stdout'
+            }
+          )
+          expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+            {
+              method: :actions_to_read_logs,
+              node: 'node'
+            },
+            {
+              method: :logs_for,
+              node: 'node',
+              exit_status: 42,
+              stdout: 'Log files read stdout',
+              stderr: 'Log files read stderr'
+            }
+          ]
         end
       end
-    end
-
-    it 'gets deployment info from log files' do
-      with_test_platform({ nodes: { 'node' => {} } }) do |repository|
-        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: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' })
-            { 'node' => [0, "Property1: Value1\nProperty2: Value2", ''] }
-          end
-        ])
-        expect(test_deployer.deployment_info_from('node')).to eq(
-          'node' => {
-            Property1: 'Value1',
-            Property2: 'Value2'
-          }
-        )
-      end
-    end
 
-    it 'gets deployment info with some properties converted from log files' do
-      with_test_platform({ nodes: { 'node' => {} } }) do |repository|
-        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: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' })
-            { 'node' => [0, <<~EOS, ''] }
-              date: Thu Nov 23 18:43:01 UTC 2017
-              debug: Yes
-              diff_files_0: file1, file2, file3
-              services: service1, service2, service3
-            EOS
-          end
-        ])
-        expect(test_deployer.deployment_info_from('node')).to eq(
-          'node' => {
-            date: Time.parse('2017-11-23 18:43:01 UTC'),
-            debug: true,
-            diff_files_0: %w[file1 file2 file3],
-            services: %w[service1 service2 service3]
-          }
-        )
-      end
-    end
-
-    it 'gets deployment info from several log files' do
-      with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
-        expect_actions_executor_runs([
-          # Expect the actions to get log files
-          proc do |actions_per_nodes|
-            expect(actions_per_nodes).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\'' }
-            )
+      it 'gets deployment info from log plugins not having actions_to_read_logs' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }, false, 'send_logs_to :test_log_no_read') do |repository|
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: { user: 'test_user' },
+              exit_status: 666,
+              services: %w[unknown],
+              stderr: 'Deployment test stderr',
+              stdout: 'Deployment test stdout'
+            }
+          )
+          expect(HybridPlatformsConductorTest::TestLogNoReadPlugin.calls).to eq [
             {
-              'node1' => [0, "Property1: Value1\nProperty2: Value2", ''],
-              'node2' => [0, "Property3: Value3\nProperty4: Value4", '']
+              method: :logs_for,
+              node: 'node',
+              exit_status: nil,
+              stdout: nil,
+              stderr: nil
             }
-          end
-        ])
-        expect(test_deployer.deployment_info_from(%w[node1 node2])).to eq(
-          'node1' => {
-            Property1: 'Value1',
-            Property2: 'Value2'
-          },
-          'node2' => {
-            Property3: 'Value3',
-            Property4: 'Value4'
-          }
-        )
+          ]
+        end
       end
+
     end
 
   end

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

@@ -0,0 +1,223 @@
+describe HybridPlatformsConductor::Deployer do
+
+  context 'checking log plugins' do
+
+    context 'remote_fs' do
+
+      # Return a test platform ready to test the remote_fs log plugin
+      #
+      # Parameters::
+      # * Proc: Code called with platform prepared
+      def with_test_platform_for_remote_fs
+        with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, false, 'send_logs_to :remote_fs') do
+          yield
+        end
+      end
+
+      it 'returns actions to save logs' do
+        with_test_platform_for_remote_fs do
+          with_connections_mocked_on ['node'] 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
+                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
+            ])
+            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 using root' do
+        with_test_platform_for_remote_fs do
+          with_connections_mocked_on ['node'] do
+            test_actions_executor.connector(:ssh).ssh_user = 'root'
+            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: root
+                  debug: No
+                  services: service1, service2
+                  exit_status: 0
+                  ===== STDOUT =====
+                  Deploy successful stdout
+                  ===== STDERR =====
+                  Deploy successful stderr
+                EOREGEXP
+                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
+            ])
+            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([
+            # 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, <<~EOS, ''] }
+                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
+              EOS
+            end
+          ])
+          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
+
+      it 'reads logs using root' do
+        with_test_platform_for_remote_fs do
+          test_actions_executor.connector(:ssh).ssh_user = 'root'
+          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, <<~EOS, ''] }
+                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
+              EOS
+            end
+          ])
+          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