hybrid_platforms_conductor 32.16.3 → 33.0.0

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/deployer/secrets_reader_plugins/cli_spec.rb

@@ -0,0 +1,63 @@
+describe HybridPlatformsConductor::Deployer do
+
+  context 'checking secrets_reader plugins' do
+
+    context 'cli' 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_cli_test
+        with_test_platform(
+          { nodes: { 'node' => { services: %w[service] } } },
+          false,
+          'read_secrets_from :cli'
+        ) do |repository|
+          yield repository
+        end
+      end
+
+      it 'gets secrets from a file' do
+        with_test_platform_for_cli_test do |repository|
+          secrets_file = "#{repository}/my_secrets.json"
+          File.write(secrets_file, '{ "secret_name": "secret_value" }')
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node' => %w[service] },
+            secrets: { 'secret_name' => 'secret_value' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { run 'deploy', '--node', 'node', '--secrets', secrets_file }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'gets secrets from several files' do
+        with_test_platform_for_cli_test 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_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node' => %w[service] },
+            secrets: { 'secret1' => 'value1', 'secret2' => 'value2' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { run 'deploy', '--node', 'node', '--secrets', secrets_file1, '--secrets', secrets_file2 }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'fails to get secrets from a missing file' do
+        with_test_platform_for_cli_test do
+          expect do
+            run 'deploy', '--node', 'node', '--secrets', 'unknown_file.json'
+          end.to raise_error 'Missing secrets file: unknown_file.json'
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/deployer/secrets_reader_plugins/thycotic_spec.rb

@@ -0,0 +1,253 @@
+require 'savon'
+
+describe HybridPlatformsConductor::Deployer do
+
+  context 'checking secrets_reader plugins' do
+
+    context 'thycotic' do
+
+      # Setup a platform for tests
+      #
+      # Parameters::
+      # * *additional_config* (String): Additional config
+      # * *platform_info* (Hash): Platform configuration [default: 1 node having 1 service]
+      # * Proc: Code called when the platform is setup
+      def with_test_platform_for_thycotic_test(additional_config = '', platform_info: { nodes: { 'node' => { services: %w[service] } } })
+        with_test_platform(
+          platform_info,
+          false,
+          "read_secrets_from :thycotic\n" + additional_config
+        ) do
+          yield
+        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 Thycotic Secret Server' do
+        with_test_platform_for_thycotic_test(
+          <<~EOS
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic.domain.com/SecretServer',
+              secret_id: 1107
+            )
+          EOS
+        ) do
+          mock_thycotic_file_download_on('https://my_thycotic.domain.com/SecretServer', 1107, '{ "secret_name": "secret_value" }')
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node' => %w[service] },
+            secrets: { 'secret_name' => 'secret_value' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { test_deployer.deploy_on(%w[node]) }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'gets secrets from a Thycotic Secret Server for several nodes' do
+        additional_config = <<~EOS
+          secrets_from_thycotic(
+            thycotic_url: 'https://my_thycotic.domain.com/SecretServer',
+            secret_id: 1107
+          )
+        EOS
+        with_test_platform_for_thycotic_test(additional_config, platform_info: { nodes: { 'node1' => { services: %w[service1] }, 'node2' => { services: %w[service2] } } }) do
+          mock_thycotic_file_download_on('https://my_thycotic.domain.com/SecretServer', 1107, '{ "secret_name": "secret_value" }')
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node1' => %w[service1], 'node2' => %w[service2] },
+            secrets: { 'secret_name' => 'secret_value' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { test_deployer.deploy_on(%w[node1 node2]) }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'gets secrets from a Thycotic Secret Server using env variables' do
+        with_test_platform_for_thycotic_test(
+          <<~EOS
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic.domain.com/SecretServer',
+              secret_id: 1107
+            )
+          EOS
+        ) do
+          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'
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node' => %w[service] },
+            secrets: { 'secret_name' => 'secret_value' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { test_deployer.deploy_on(%w[node]) }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'gets secrets from several Thycotic Secret Servers' do
+        additional_config = <<~EOS
+          secrets_from_thycotic(
+            thycotic_url: 'https://my_thycotic1.domain.com/SecretServer',
+            secret_id: 110701
+          )
+          for_nodes('node2') do
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic2.domain.com/SecretServer',
+              secret_id: 110702
+            )
+          end
+        EOS
+        with_test_platform_for_thycotic_test(additional_config, platform_info: { nodes: { 'node1' => { services: %w[service1] }, 'node2' => { services: %w[service2] } } }) do
+          mock_thycotic_file_download_on('https://my_thycotic1.domain.com/SecretServer', 110701, '{ "secret1": "value1" }')
+          mock_thycotic_file_download_on('https://my_thycotic2.domain.com/SecretServer', 110702, '{ "secret2": "value2" }')
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node1' => %w[service1], 'node2' => %w[service2] },
+            secrets: { 'secret1' => 'value1', 'secret2' => 'value2' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { test_deployer.deploy_on(%w[node1 node2]) }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'merges secrets from several Thycotic Secret Servers' do
+        with_test_platform_for_thycotic_test(
+          <<~EOS
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic1.domain.com/SecretServer',
+              secret_id: 110701
+            )
+            for_nodes('node') do
+              secrets_from_thycotic(
+                thycotic_url: 'https://my_thycotic2.domain.com/SecretServer',
+                secret_id: 110702
+              )
+            end
+          EOS
+        ) do
+          mock_thycotic_file_download_on('https://my_thycotic1.domain.com/SecretServer', 110701, '{ "secret1": "value1", "secret2": "value2" }')
+          mock_thycotic_file_download_on('https://my_thycotic2.domain.com/SecretServer', 110702, '{ "secret2": "value2", "secret3": "value3" }')
+          expect(test_services_handler).to receive(:deploy_allowed?).with(
+            services: { 'node' => %w[service] },
+            secrets: { 'secret1' => 'value1', 'secret2' => 'value2', 'secret3' => 'value3' },
+            local_environment: false
+          ) { 'Abort as testing secrets is enough' }
+          expect { test_deployer.deploy_on(%w[node]) }.to raise_error 'Deployment not allowed: Abort as testing secrets is enough'
+        end
+      end
+
+      it 'fails in case of secrets conflicts from several Thycotic Secret Servers' do
+        with_test_platform_for_thycotic_test(
+          <<~EOS
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic1.domain.com/SecretServer',
+              secret_id: 110701
+            )
+            for_nodes('node') do
+              secrets_from_thycotic(
+                thycotic_url: 'https://my_thycotic2.domain.com/SecretServer',
+                secret_id: 110702
+              )
+            end
+          EOS
+        ) do
+          mock_thycotic_file_download_on('https://my_thycotic1.domain.com/SecretServer', 110701, '{ "secret1": "value1", "secret2": "value2" }')
+          mock_thycotic_file_download_on('https://my_thycotic2.domain.com/SecretServer', 110702, '{ "secret2": "other_value", "secret3": "value3" }')
+          expect { test_deployer.deploy_on(%w[node]) }.to raise_error 'Thycotic secret secret2 served by https://my_thycotic2.domain.com/SecretServer from secret ID 110702 has conflicting values between different secrets.'
+        end
+      end
+
+      it 'fails to get secrets from a missing Thycotic Secret Server' do
+        with_test_platform_for_thycotic_test(
+          <<~EOS
+            secrets_from_thycotic(
+              thycotic_url: 'https://my_thycotic.domain.com/SecretServer',
+              secret_id: 1107
+            )
+          EOS
+        ) do
+          mock_thycotic_file_download_on('https://my_thycotic.domain.com/SecretServer', 1107, nil)
+          expect { test_deployer.deploy_on(%w[node]) }.to raise_error 'Unable to fetch secret file ID 1107 from https://my_thycotic.domain.com/SecretServer'
+        end
+      end
+
+    end
+
+  end
+
+end

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