hybrid_platforms_conductor 32.17.0 → 33.0.2

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

@@ -1,24 +1,24 @@
 describe HybridPlatformsConductor::ActionsExecutor do
 
-  context 'checking timeouts' do
+  context 'when checking timeouts' do
 
     # Get a test platform to test timeouts
     #
     # Parameters::
-    # * Proc: Code called with platform setup
-    def with_test_platform_for_timeouts_tests
-      with_test_platform_for_executor(nodes: { 'node' => {} }) do
-        yield
-      end
+    # * *block* (Proc): Code called with platform setup
+    def with_test_platform_for_timeouts_tests(&block)
+      with_test_platform_for_executor(nodes: { 'node' => {} }, &block)
     end
 
     it 'executes an action without timeout' do
       with_test_platform_for_timeouts_tests do
         expect(test_actions_executor.execute_actions(
-          'node' => { test_action: { code: proc do |stdout, _stderr, action|
-            expect(action.timeout).to eq nil
-            stdout << 'Hello'
-          end } }
+          {
+            'node' => { test_action: { code: proc do |stdout, _stderr, action|
+              expect(action.timeout).to eq nil
+              stdout << 'Hello'
+            end } }
+          }
         )['node']).to eq [0, 'Hello', '']
       end
     end
@@ -38,7 +38,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
     it 'executes an action that fails because of timeout' do
       with_test_platform_for_timeouts_tests do
         expect(test_actions_executor.execute_actions(
-          { 'node' => { test_action: { code: proc do |_stdout, _stderr, action|
+          { 'node' => { test_action: { code: proc do
             raise HybridPlatformsConductor::CmdRunner::TimeoutError
           end } } },
           timeout: 1
@@ -49,7 +49,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
     it 'executes an action that fails because of timeout and outputs data before' do
       with_test_platform_for_timeouts_tests do
         expect(test_actions_executor.execute_actions(
-          { 'node' => { test_action: { code: proc do |stdout, _stderr, action|
+          { 'node' => { test_action: { code: proc do |stdout|
             stdout << 'Hello'
             raise HybridPlatformsConductor::CmdRunner::TimeoutError
           end } } },
@@ -66,7 +66,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
               sleep 1
               stdout << 'Hello'
             end } },
-            { test_action: { code: proc do |stdout, _stderr, action|
+            { test_action: { code: proc do
               raise HybridPlatformsConductor::CmdRunner::TimeoutError
             end } }
           ] },
@@ -79,15 +79,15 @@ describe HybridPlatformsConductor::ActionsExecutor do
       with_test_platform_for_timeouts_tests do
         expect(test_actions_executor.execute_actions(
           { 'node' => [
-            { test_action: { code: proc do |stdout, _stderr, action|
+            { test_action: { code: proc do |_stdout, _stderr, action|
               expect(action.timeout).to eq 5
               sleep 1
             end } },
-            { test_action: { code: proc do |stdout, _stderr, action|
+            { test_action: { code: proc do |_stdout, _stderr, action|
               expect(action.timeout).to be_between(3.8, 4)
               sleep 1
             end } },
-            { test_action: { code: proc do |stdout, _stderr, action|
+            { test_action: { code: proc do |_stdout, _stderr, action|
               expect(action.timeout).to be_between(2.8, 3)
             end } }
           ] },

data/spec/hybrid_platforms_conductor_test/api/cmd_runner_spec.rb

@@ -8,21 +8,21 @@ describe HybridPlatformsConductor::CmdRunner do
   end
 
   it 'runs a simple bash command and returns exit code, stdout and stderr correctly' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; echo TestStdout").to eq [0, "TestStdout\n", "TestStderr\n"]
+    with_repository do
+      expect(test_cmd_runner.run_cmd('echo TestStderr 1>&2 ; echo TestStdout')).to eq [0, "TestStdout\n", "TestStderr\n"]
     end
   end
 
   it 'runs a simple bash command and forces usage of bash' do
-    with_repository do |repository|
+    with_repository do
       # Use set -o pipefail that does not work in /bin/sh
-      expect(test_cmd_runner.run_cmd "set -o pipefail ; echo TestStderr 1>&2 ; echo TestStdout", force_bash: true).to eq [0, "TestStdout\n", "TestStderr\n"]
+      expect(test_cmd_runner.run_cmd('set -o pipefail ; echo TestStderr 1>&2 ; echo TestStdout', force_bash: true)).to eq [0, "TestStdout\n", "TestStderr\n"]
     end
   end
 
   it 'runs a simple bash command and logs stdout and stderr to a file' do
     with_repository do |repository|
-      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_to_file: "#{repository}/test_file"
+      test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout', log_to_file: "#{repository}/test_file"
       expect(File.read("#{repository}/test_file")).to eq "TestStderr\nTestStdout\n"
     end
   end
@@ -30,102 +30,102 @@ describe HybridPlatformsConductor::CmdRunner do
   it 'runs a simple bash command and logs stdout and stderr to an existing file' do
     with_repository do |repository|
       File.write("#{repository}/test_file", "Before\n")
-      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_to_file: "#{repository}/test_file"
+      test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout', log_to_file: "#{repository}/test_file"
       expect(File.read("#{repository}/test_file")).to eq "Before\nTestStderr\nTestStdout\n"
     end
   end
 
   it 'runs a simple bash command and logs stdout and stderr to IO objects' do
-    with_repository do |repository|
+    with_repository do
       stdout = ''
       stderr = ''
-      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_stdout_to_io: stdout, log_stderr_to_io: stderr
+      test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout', log_stdout_to_io: stdout, log_stderr_to_io: stderr
       expect(stdout).to eq "TestStdout\n"
       expect(stderr).to eq "TestStderr\n"
     end
   end
 
   it 'fails when the command does not exit 0' do
-    with_repository do |repository|
+    with_repository do
       expect { test_cmd_runner.run_cmd 'exit 1' }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 0).')
     end
   end
 
   it 'fails when the command does not exit with the expected code' do
-    with_repository do |repository|
+    with_repository do
       expect { test_cmd_runner.run_cmd 'exit 1', expected_code: 2 }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 2).')
     end
   end
 
   it 'fails when the command does not exit with one of the expected codes' do
-    with_repository do |repository|
+    with_repository do
       expect { test_cmd_runner.run_cmd 'exit 1', expected_code: [0, 2, 3] }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 0, 2, 3).')
     end
   end
 
   it 'does not fail when the command exits with the expected code' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'exit 2', expected_code: 2).to eq [2, '', '']
+    with_repository do
+      expect(test_cmd_runner.run_cmd('exit 2', expected_code: 2)).to eq [2, '', '']
     end
   end
 
   it 'does not fail when the command exits with one of the expected codes' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'exit 2', expected_code: [0, 2, 3]).to eq [2, '', '']
+    with_repository do
+      expect(test_cmd_runner.run_cmd('exit 2', expected_code: [0, 2, 3])).to eq [2, '', '']
     end
   end
 
   it 'does not fail when the command does not exit 0 and we specify no exception' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'exit 1', no_exception: true).to eq [1, '', '']
+    with_repository do
+      expect(test_cmd_runner.run_cmd('exit 1', no_exception: true)).to eq [1, '', '']
     end
   end
 
   it 'does not fail when the command can\'t be run and we specify no exception' do
-    with_repository do |repository|
+    with_repository do
       exit_status, stdout, stderr = test_cmd_runner.run_cmd 'unknown_command', no_exception: true
       expect(exit_status).to eq :command_error
       expect(stdout).to eq ''
-      expect(stderr).to match /^No such file or directory - unknown_command.*/
+      expect(stderr).to match(/^No such file or directory - unknown_command.*/)
     end
   end
 
   it 'does not fail when the command is expected to not be run' do
-    with_repository do |repository|
+    with_repository do
       exit_status, stdout, stderr = test_cmd_runner.run_cmd 'unknown_command', expected_code: :command_error
       expect(exit_status).to eq :command_error
       expect(stdout).to eq ''
-      expect(stderr).to match /^No such file or directory - unknown_command.*/
+      expect(stderr).to match(/^No such file or directory - unknown_command.*/)
     end
   end
 
   it 'fails when the command times out' do
-    with_repository do |repository|
+    with_repository do
       expect { test_cmd_runner.run_cmd 'sleep 5', timeout: 1 }.to raise_error(HybridPlatformsConductor::CmdRunner::TimeoutError, 'Command \'sleep 5\' returned error code timeout (expected 0).')
     end
   end
 
   it 'returns the timeout error when the command times out and we specify no exception' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'sleep 5', timeout: 1, no_exception: true).to eq [:timeout, '', 'Timeout of 1 triggered']
+    with_repository do
+      expect(test_cmd_runner.run_cmd('sleep 5', timeout: 1, no_exception: true)).to eq [:timeout, '', 'Timeout of 1 triggered']
     end
   end
 
   it 'returns the timeout error when the command is expected to time out' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'sleep 5', timeout: 1, expected_code: :timeout).to eq [:timeout, '', 'Timeout of 1 triggered']
+    with_repository do
+      expect(test_cmd_runner.run_cmd('sleep 5', timeout: 1, expected_code: :timeout)).to eq [:timeout, '', 'Timeout of 1 triggered']
     end
   end
 
   it 'returns the timeout error with previously output stdout and stderr when the command times out and we specify no exception' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, no_exception: true).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
+    with_repository do
+      expect(test_cmd_runner.run_cmd('echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, no_exception: true)).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
     end
   end
 
   it 'returns the timeout error with previously output stdout and stderr when the command times out as expected' do
-    with_repository do |repository|
-      expect(test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, expected_code: :timeout).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
+    with_repository do
+      expect(test_cmd_runner.run_cmd('echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, expected_code: :timeout)).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
     end
   end
 
@@ -133,7 +133,7 @@ describe HybridPlatformsConductor::CmdRunner do
     with_repository do |repository|
       cmd_runner = test_cmd_runner
       cmd_runner.dry_run = true
-      expect(cmd_runner.run_cmd "echo TestContent >#{repository}/test_file").to eq [0, '', '']
+      expect(cmd_runner.run_cmd("echo TestContent >#{repository}/test_file")).to eq [0, '', '']
       expect(File.exist?("#{repository}/test_file")).to eq false
     end
   end
@@ -142,31 +142,31 @@ describe HybridPlatformsConductor::CmdRunner do
     with_repository do |repository|
       cmd_runner = test_cmd_runner
       cmd_runner.dry_run = true
-      expect(cmd_runner.run_cmd "echo TestContent >#{repository}/test_file", expected_code: 2).to eq [2, '', '']
+      expect(cmd_runner.run_cmd("echo TestContent >#{repository}/test_file", expected_code: 2)).to eq [2, '', '']
       expect(File.exist?("#{repository}/test_file")).to eq false
     end
   end
 
   it 'returns the currently logged user' do
     cmd_runner = test_cmd_runner
-    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'test_user', ''] }
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false).and_return [0, 'test_user', '']
     expect(cmd_runner.whoami).to eq 'test_user'
   end
 
   it 'returns non-root user when user is not root' do
     cmd_runner = test_cmd_runner
-    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'not_root', ''] }
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false).and_return [0, 'not_root', '']
     expect(cmd_runner.root?).to eq false
   end
 
   it 'returns root user when user is root' do
     cmd_runner = test_cmd_runner
-    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'root', ''] }
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false).and_return [0, 'root', '']
     expect(cmd_runner.root?).to eq true
   end
 
   it 'returns the correct executable prefix' do
-    expect(HybridPlatformsConductor::CmdRunner.executables_prefix).to eq "#{File.dirname($0)}/"
+    expect(described_class.executables_prefix).to eq "#{File.dirname($PROGRAM_NAME)}/"
   end
 
 end

data/spec/hybrid_platforms_conductor_test/api/config_spec.rb

@@ -7,23 +7,23 @@ describe HybridPlatformsConductor::Config do
   end
 
   it 'returns 1 defined OS image' do
-    with_platforms 'os_image :image1, \'/path/to/image1\'' do
-      expect(test_config.known_os_images).to eq [:image1]
+    with_platforms 'os_image :image_1, \'/path/to/image_1\'' do
+      expect(test_config.known_os_images).to eq [:image_1]
     end
   end
 
   it 'returns 1 defined OS image with its directory' do
-    with_platforms 'os_image :image1, \'/path/to/image1\'' do
-      expect(test_config.os_image_dir(:image1)).to eq '/path/to/image1'
+    with_platforms 'os_image :image_1, \'/path/to/image_1\'' do
+      expect(test_config.os_image_dir(:image_1)).to eq '/path/to/image_1'
     end
   end
 
   it 'returns several defined OS images' do
     with_platforms '
-      os_image :image1, \'/path/to/image1\'
-      os_image :image2, \'/path/to/image2\'
+      os_image :image_1, \'/path/to/image_1\'
+      os_image :image_2, \'/path/to/image_2\'
     ' do
-      expect(test_config.known_os_images.sort).to eq %i[image1 image2].sort
+      expect(test_config.known_os_images.sort).to eq %i[image_1 image_2].sort
     end
   end
 
@@ -35,30 +35,32 @@ describe HybridPlatformsConductor::Config do
 
   it 'accesses the platform handler repositories if needed from the config' do
     with_repository do |repository|
-      with_platforms "
-        test_platform path: '#{repository}' do |repository_path|
-          os_image :image1, \"\#{repository_path}/image_path\"
-        end
-      " do
-        expect(test_config.known_os_images.sort).to eq %i[image1].sort
-        expect(test_config.os_image_dir(:image1)).to eq "#{repository}/image_path"
+      with_platforms(
+        <<~EO_CONFIG
+          test_platform path: '#{repository}' do |repository_path|
+            os_image :image_1, "\#{repository_path}/image_path"
+          end
+        EO_CONFIG
+      ) do
+        expect(test_config.known_os_images.sort).to eq %i[image_1].sort
+        expect(test_config.os_image_dir(:image_1)).to eq "#{repository}/image_path"
       end
     end
   end
 
   it 'includes several configuration files' do
     with_platforms '
-      os_image :image1, \'/path/to/image1\'
+      os_image :image_1, \'/path/to/image_1\'
       include_config_from "#{__dir__}/my_conf_1.rb"
       include_config_from "#{__dir__}/my_conf_2.rb"
     ' do |hybrid_platforms_dir|
-      File.write("#{hybrid_platforms_dir}/my_conf_1.rb", <<~EOS)
-        os_image :image4, '/path/to/image4'
-        include_config_from "\#{__dir__}/my_conf_3.rb"
-      EOS
-      File.write("#{hybrid_platforms_dir}/my_conf_2.rb", 'os_image :image2, \'/path/to/image2\'')
-      File.write("#{hybrid_platforms_dir}/my_conf_3.rb", 'os_image :image3, \'/path/to/image3\'')
-      expect(test_config.known_os_images.sort).to eq %i[image1 image2 image3 image4].sort
+      File.write("#{hybrid_platforms_dir}/my_conf_1.rb", <<~'EO_CONFIG')
+        os_image :image_4, '/path/to/image_4'
+        include_config_from "#{__dir__}/my_conf_3.rb"
+      EO_CONFIG
+      File.write("#{hybrid_platforms_dir}/my_conf_2.rb", 'os_image :image_2, \'/path/to/image_2\'')
+      File.write("#{hybrid_platforms_dir}/my_conf_3.rb", 'os_image :image_3, \'/path/to/image_3\'')
+      expect(test_config.known_os_images.sort).to eq %i[image_1 image_2 image_3 image_4].sort
     end
   end
 

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

@@ -1,8 +1,10 @@
 describe HybridPlatformsConductor::Deployer do
 
-  context 'checking why-run mode' do
+  context 'when checking why-run mode' do
 
-    deploy_specs_for(check_mode: true)
+    it_behaves_like 'a deployer' do
+      let(:check_mode) { true }
+    end
 
   end
 

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

@@ -1,12 +1,50 @@
 describe HybridPlatformsConductor::Deployer do
 
-  context 'checking deployer specific config DSL' do
+  context 'when checking deployer specific config DSL' do
 
     it 'declares a packaging timeout' do
-      with_repository do |repository|
-        with_platforms('packaging_timeout 666') do
-          expect(test_config.packaging_timeout_secs).to eq 666
-        end
+      with_platforms('packaging_timeout 666') do
+        expect(test_config.packaging_timeout_secs).to eq 666
+      end
+    end
+
+    it 'declares log plugins to be used' do
+      with_platforms(
+        <<~EO_CONFIG
+          send_logs_to %i[log_plugin_1 log_plugin_2]
+          for_nodes('node2') { send_logs_to :log_plugin_3 }
+        EO_CONFIG
+      ) do
+        expect(test_config.deployment_logs).to eq [
+          {
+            nodes_selectors_stack: [],
+            log_plugins: %i[log_plugin_1 log_plugin_2]
+          },
+          {
+            nodes_selectors_stack: %w[node2],
+            log_plugins: %i[log_plugin_3]
+          }
+        ]
+      end
+    end
+
+    it 'declares secrets readers plugins to be used' do
+      with_platforms(
+        <<~EO_CONFIG
+          read_secrets_from %i[secrets_reader_plugin_1 secrets_reader_plugin_2]
+          for_nodes('node2') { read_secrets_from :secrets_reader_plugin_3 }
+        EO_CONFIG
+      ) do
+        expect(test_config.secrets_readers).to eq [
+          {
+            nodes_selectors_stack: [],
+            secrets_readers: %i[secrets_reader_plugin_1 secrets_reader_plugin_2]
+          },
+          {
+            nodes_selectors_stack: %w[node2],
+            secrets_readers: %i[secrets_reader_plugin_3]
+          }
+        ]
       end
     end
 

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

@@ -1,241 +1,224 @@
 describe HybridPlatformsConductor::Deployer do
 
-  context 'checking real deploy mode' do
+  context 'when checking real deploy mode' do
 
-    deploy_specs_for(check_mode: false)
+    it_behaves_like 'a deployer' do
+      let(:check_mode) { false }
+    end
+
+    context 'when checking log plugins usage' do
 
-    # 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
+      # Prepare the test platform with test log plugins
+      #
+      # Parameters::
+      # * *platforms_info* (Hash): The platforms info
+      # * *as_git* (Boolean): As a git repository? [default: false]
+      # * *additional_config* (String): Additional config [default: 'send_logs_to :test_log']
+      # * *block* (Proc): Code called with the platform setup
+      #   * Parameters::
+      #     * *repository* (String): Platform's repository
+      def with_test_platform_for_deploy_tests(platforms_info, as_git: false, additional_config: 'send_logs_to :test_log', &block)
+        with_test_platform(platforms_info, as_git: as_git, additional_config: additional_config, &block)
       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}\"" }]
-        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(', ')}"
-          }
+
+      it 'deploys correct logs information on 1 node' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, as_git: 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] }
+            }
+          },
+          as_git: 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] } } }, as_git: 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])
-          expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
+      it 'gets deployment info from log plugins' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }) do
+          expect_actions_executor_runs [
+            # 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' => {} } }, additional_config: 'send_logs_to :test_log_no_read') do
+          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