hybrid_platforms_conductor 32.16.2 → 32.18.0

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

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

@@ -54,8 +54,8 @@ describe HybridPlatformsConductor::Deployer do
       with_test_platform(
         {
           nodes: {
-            'node1' => { meta: { host_ip: '192.168.42.1', ssh_session_exec: 'false' } },
-            'node2' => { meta: { host_ip: '192.168.42.2', ssh_session_exec: 'false' } }
+            'node1' => { meta: { host_ip: '192.168.42.1', ssh_session_exec: false } },
+            'node2' => { meta: { host_ip: '192.168.42.2', ssh_session_exec: false } }
           }
         },
         false,
@@ -75,8 +75,8 @@ describe HybridPlatformsConductor::Deployer do
           block.call
         end
         test_deployer.with_test_provisioned_instance(:test_provisioner, 'node1', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
-          expect(sub_test_deployer.instance_eval { @nodes_handler.get_ssh_session_exec_of('node1') }).to eq 'true'
-          expect(sub_test_deployer.instance_eval { @nodes_handler.get_ssh_session_exec_of('node2') }).to eq 'false'
+          expect(sub_test_deployer.instance_eval { @nodes_handler.get_ssh_session_exec_of('node1') }).to eq true
+          expect(sub_test_deployer.instance_eval { @nodes_handler.get_ssh_session_exec_of('node2') }).to eq false
           ssh_transforms = test_instance.instance_eval { @config.ssh_connection_transforms }
           expect(ssh_transforms.size).to eq 1
           expect(ssh_transforms[0][:nodes_selectors_stack]).to eq [%w[node2]]

data/spec/hybrid_platforms_conductor_test/api/platform_handlers/serverless_chef/packaging_spec.rb

@@ -26,7 +26,7 @@ describe HybridPlatformsConductor::HpcPlugins::PlatformHandler::ServerlessChef d
         if install
           [
             [
-              "cd #{repository} && /opt/chef-workstation/bin/chef install #{policy_file}",
+              "cd #{repository} && /opt/chef-workstation/bin/chef install #{policy_file} --chef-license accept",
               proc do
                 # Mock the run_list stored in the lock file
                 File.write(
@@ -46,7 +46,7 @@ describe HybridPlatformsConductor::HpcPlugins::PlatformHandler::ServerlessChef d
           [
             ['whoami', proc { [0, 'test_user', ''] }, { optional: true }],
             [
-              /^cd #{Regexp.escape(repository)} &&\s+sudo rm -rf dist\/#{Regexp.escape(env)}\/#{Regexp.escape(policy)} &&\s+\/opt\/chef-workstation\/bin\/chef export #{Regexp.escape(policy_file)} dist\/#{Regexp.escape(env)}\/#{Regexp.escape(policy)}#{data_bags ? " && cp -ar data_bags/ dist/#{Regexp.escape(env)}/#{Regexp.escape(policy)}/" : ''}$/,
+              /^cd #{Regexp.escape(repository)} &&\s+sudo rm -rf dist\/#{Regexp.escape(env)}\/#{Regexp.escape(policy)} &&\s+\/opt\/chef-workstation\/bin\/chef export #{Regexp.escape(policy_file)} dist\/#{Regexp.escape(env)}\/#{Regexp.escape(policy)} --chef-license accept#{data_bags ? " && cp -ar data_bags/ dist/#{Regexp.escape(env)}/#{Regexp.escape(policy)}/" : ''}$/,
               proc do
                 FileUtils.mkdir_p "#{repository}/dist/#{env}/#{policy}"
                 FileUtils.cp_r("#{repository}/data_bags", "#{repository}/dist/#{env}/#{policy}/") if data_bags

data/spec/hybrid_platforms_conductor_test/api/tests_runner/global_spec.rb

@@ -5,7 +5,7 @@ describe HybridPlatformsConductor::TestsRunner do
     # Prepare the test platform with test plugins
     #
     # Parameters::
-    # * *platforms_info* (Hash): The platofrms info [default: {}]
+    # * *platforms_info* (Hash): The platforms info [default: {}]
     def with_test_platform_for_global_tests(platforms_info: {})
       with_test_platform(platforms_info) do
         register_test_plugins(test_tests_runner,

data/spec/hybrid_platforms_conductor_test/api/tests_runner/test_plugins/github_ci_spec.rb

@@ -0,0 +1,72 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking test plugins' do
+
+    context 'checking github_ci' do
+
+      it 'iterates over defined Github repos' do
+        with_repository do |repository|
+          platforms = <<~EOS
+            github_repos(
+              url: 'https://my_gh.my_domain.com',
+              user: 'GH-User1',
+              repos: [
+                'repo1',
+                'repo2'
+              ]
+            )
+            github_repos(
+              user: 'GH-User2',
+              repos: [
+                'repo3',
+                'repo4'
+              ]
+            )
+          EOS
+          with_platforms platforms do
+            repos = []
+            test_config.for_each_github_repo do |github, repo_info|
+              repos << {
+                github_url: github.api_endpoint,
+                repo_info: repo_info
+              }
+            end
+            expect(repos).to eq [
+              {
+                github_url: 'https://my_gh.my_domain.com/',
+                repo_info: {
+                  name: 'repo1',
+                  slug: 'GH-User1/repo1'
+                }
+              },
+              {
+                github_url: 'https://my_gh.my_domain.com/',
+                repo_info: {
+                  name: 'repo2',
+                  slug: 'GH-User1/repo2'
+                }
+              },
+              {
+                github_url: 'https://api.github.com/',
+                repo_info: {
+                  name: 'repo3',
+                  slug: 'GH-User2/repo3'
+                }
+              },
+              {
+                github_url: 'https://api.github.com/',
+                repo_info: {
+                  name: 'repo4',
+                  slug: 'GH-User2/repo4'
+                }
+              }
+            ]
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/last_deploys_spec.rb

@@ -14,33 +14,45 @@ describe 'last_deploys executable' do
 
   it 'checks all nodes by default' do
     with_test_platform_for_last_deploys do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        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'" }
-        )
+      expect(test_deployer).to receive(:deployment_info_from).with(%w[node1 node2]) do
         {
-          'node1' => [0, <<~EOS, ''],
-            date: 2019-08-21 10:12:15
-            user: admin_user1
-            services: service1
-          EOS
-          'node2' => [0, <<~EOS, '']
-            date: 2019-08-22 10:12:15
-            user: admin_user2
-            services: service1, service2
-          EOS
+          'node1' => {
+            services: %w[service1],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef1',
+              exit_status: 0,
+              date: Time.parse('2019-08-21 10:12:15 UTC'),
+              user: 'admin_user1'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          },
+          'node2' => {
+            services: %w[service1 service2],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef2',
+              exit_status: 0,
+              date: Time.parse('2019-08-22 10:12:15 UTC'),
+              user: 'admin_user2'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          }
         }
-      end])
+      end
       exit_code, stdout, stderr = run 'last_deploys'
       expect(exit_code).to eq 0
       expect(stdout).to eq(<<~EOS)
-        +-------+---------------------+-------------+--------------------+-------+
-        | Node  | Date                | Admin       | Services           | Error |
-        +-------+---------------------+-------------+--------------------+-------+
-        | node1 | 2019-08-21 10:12:15 | admin_user1 | service1           |       |
-        | node2 | 2019-08-22 10:12:15 | admin_user2 | service1, service2 |       |
-        +-------+---------------------+-------------+--------------------+-------+
+        +-------+-------------------------+-------------+--------------------+-------+
+        | Node  | Date                    | Admin       | Services           | Error |
+        +-------+-------------------------+-------------+--------------------+-------+
+        | node1 | 2019-08-21 10:12:15 UTC | admin_user1 | service1           |       |
+        | node2 | 2019-08-22 10:12:15 UTC | admin_user2 | service1, service2 |       |
+        +-------+-------------------------+-------------+--------------------+-------+
       EOS
       expect(stderr).to eq ''
     end
@@ -48,33 +60,45 @@ describe 'last_deploys executable' do
 
   it 'sorts results by user' do
     with_test_platform_for_last_deploys do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        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'" }
-        )
+      expect(test_deployer).to receive(:deployment_info_from).with(%w[node1 node2]) do
         {
-          'node1' => [0, <<~EOS, ''],
-            date: 2019-08-21 10:12:15
-            user: admin_user2
-            services: service1
-          EOS
-          'node2' => [0, <<~EOS, '']
-            date: 2019-08-22 10:12:15
-            user: admin_user1
-            services: service1, service2
-          EOS
+          'node1' => {
+            services: %w[service1],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef1',
+              exit_status: 0,
+              date: Time.parse('2019-08-21 10:12:15 UTC'),
+              user: 'admin_user2'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          },
+          'node2' => {
+            services: %w[service1 service2],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef2',
+              exit_status: 0,
+              date: Time.parse('2019-08-22 10:12:15 UTC'),
+              user: 'admin_user1'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          }
         }
-      end])
+      end
       exit_code, stdout, stderr = run 'last_deploys', '--sort-by', 'user'
       expect(exit_code).to eq 0
       expect(stdout).to eq(<<~EOS)
-        +-------+---------------------+-------------+--------------------+-------+
-        | Node  | Date                | Admin       | Services           | Error |
-        +-------+---------------------+-------------+--------------------+-------+
-        | node2 | 2019-08-22 10:12:15 | admin_user1 | service1, service2 |       |
-        | node1 | 2019-08-21 10:12:15 | admin_user2 | service1           |       |
-        +-------+---------------------+-------------+--------------------+-------+
+        +-------+-------------------------+-------------+--------------------+-------+
+        | Node  | Date                    | Admin       | Services           | Error |
+        +-------+-------------------------+-------------+--------------------+-------+
+        | node2 | 2019-08-22 10:12:15 UTC | admin_user1 | service1, service2 |       |
+        | node1 | 2019-08-21 10:12:15 UTC | admin_user2 | service1           |       |
+        +-------+-------------------------+-------------+--------------------+-------+
       EOS
       expect(stderr).to eq ''
     end
@@ -82,33 +106,45 @@ describe 'last_deploys executable' do
 
   it 'sorts results by user descending' do
     with_test_platform_for_last_deploys do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        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'" }
-        )
+      expect(test_deployer).to receive(:deployment_info_from).with(%w[node1 node2]) do
         {
-          'node1' => [0, <<~EOS, ''],
-            date: 2019-08-21 10:12:15
-            user: admin_user2
-            services: service1
-          EOS
-          'node2' => [0, <<~EOS, '']
-            date: 2019-08-22 10:12:15
-            user: admin_user1
-            services: service1, service2
-          EOS
+          'node1' => {
+            services: %w[service1],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef1',
+              exit_status: 0,
+              date: Time.parse('2019-08-21 10:12:15 UTC'),
+              user: 'admin_user2'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          },
+          'node2' => {
+            services: %w[service1 service2],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef2',
+              exit_status: 0,
+              date: Time.parse('2019-08-22 10:12:15 UTC'),
+              user: 'admin_user1'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          }
         }
-      end])
+      end
       exit_code, stdout, stderr = run 'last_deploys', '--sort-by', 'user_desc'
       expect(exit_code).to eq 0
       expect(stdout).to eq(<<~EOS)
-        +-------+---------------------+-------------+--------------------+-------+
-        | Node  | Date                | Admin       | Services           | Error |
-        +-------+---------------------+-------------+--------------------+-------+
-        | node1 | 2019-08-21 10:12:15 | admin_user2 | service1           |       |
-        | node2 | 2019-08-22 10:12:15 | admin_user1 | service1, service2 |       |
-        +-------+---------------------+-------------+--------------------+-------+
+        +-------+-------------------------+-------------+--------------------+-------+
+        | Node  | Date                    | Admin       | Services           | Error |
+        +-------+-------------------------+-------------+--------------------+-------+
+        | node1 | 2019-08-21 10:12:15 UTC | admin_user2 | service1           |       |
+        | node2 | 2019-08-22 10:12:15 UTC | admin_user1 | service1, service2 |       |
+        +-------+-------------------------+-------------+--------------------+-------+
       EOS
       expect(stderr).to eq ''
     end
@@ -116,24 +152,31 @@ describe 'last_deploys executable' do
 
   it 'displays only the selected nodes' do
     with_test_platform_for_last_deploys do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        expect(actions).to eq('node1' => { remote_bash: "cd /var/log/deployments && ls -t | head -1 | xargs sed '/===== STDOUT =====/q'" })
+      expect(test_deployer).to receive(:deployment_info_from).with(%w[node1]) do
         {
-          'node1' => [0, <<~EOS, ''],
-            date: 2019-08-21 10:12:15
-            user: admin_user1
-            services: service1
-          EOS
+          'node1' => {
+            services: %w[service1],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef1',
+              exit_status: 0,
+              date: Time.parse('2019-08-21 10:12:15 UTC'),
+              user: 'admin_user1'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          }
         }
-      end])
+      end
       exit_code, stdout, stderr = run 'last_deploys', '--node', 'node1'
       expect(exit_code).to eq 0
       expect(stdout).to eq(<<~EOS)
-        +-------+---------------------+-------------+----------+-------+
-        | Node  | Date                | Admin       | Services | Error |
-        +-------+---------------------+-------------+----------+-------+
-        | node1 | 2019-08-21 10:12:15 | admin_user1 | service1 |       |
-        +-------+---------------------+-------------+----------+-------+
+        +-------+-------------------------+-------------+----------+-------+
+        | Node  | Date                    | Admin       | Services | Error |
+        +-------+-------------------------+-------------+----------+-------+
+        | node1 | 2019-08-21 10:12:15 UTC | admin_user1 | service1 |       |
+        +-------+-------------------------+-------------+----------+-------+
       EOS
       expect(stderr).to eq ''
     end
@@ -141,30 +184,35 @@ describe 'last_deploys executable' do
 
   it 'displays errors when we can\'t get info from some nodes' do
     with_test_platform_for_last_deploys do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        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'" }
-        )
+      expect(test_deployer).to receive(:deployment_info_from).with(%w[node1 node2]) do
         {
-          'node1' => [:connection_error, 'Error on stdout', 'Error on stderr'],
-          'node2' => [0, <<~EOS, '']
-            date: 2019-08-22 10:12:15
-            user: admin_user1
-            services: service1, service2
-          EOS
+          'node1' => {
+            error: 'Error while getting logs'
+          },
+          'node2' => {
+            services: %w[service1 service2],
+            deployment_info: {
+              repo_name_0: 'platform',
+              commit_id_0: 'abcdef2',
+              exit_status: 0,
+              date: Time.parse('2019-08-22 10:12:15 UTC'),
+              user: 'admin_user2'
+            },
+            exit_status: 0,
+            stdout: '',
+            stderr: ''
+          }
         }
-      end])
+      end
       exit_code, stdout, stderr = run 'last_deploys', '--sort-by', 'user_desc'
       expect(exit_code).to eq 0
       expect(stdout).to eq(<<~EOS)
-        +-------+---------------------+-------------+--------------------+-------------------------+
-        | Node  | Date                | Admin       | Services           | Error                   |
-        +-------+---------------------+-------------+--------------------+-------------------------+
-        | node2 | 2019-08-22 10:12:15 | admin_user1 | service1, service2 |                         |
-        | node1 |                     |             |                    | Error: connection_error |
-        |       |                     |             |                    | Error on stderr         |
-        +-------+---------------------+-------------+--------------------+-------------------------+
+        +-------+-------------------------+-------------+--------------------+--------------------------+
+        | Node  | Date                    | Admin       | Services           | Error                    |
+        +-------+-------------------------+-------------+--------------------+--------------------------+
+        | node2 | 2019-08-22 10:12:15 UTC | admin_user2 | service1, service2 |                          |
+        | node1 |                         |             |                    | Error while getting logs |
+        +-------+-------------------------+-------------+--------------------+--------------------------+
       EOS
       expect(stderr).to eq ''
     end