hybrid_platforms_conductor 32.18.0 → 33.0.4

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,108 @@ 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 'runs a command in an un-bundled environment' do
+    with_repository do
+      expect(test_cmd_runner.run_cmd('echo "${BUNDLE_GEMFILE}"')).to eq [0, "\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 +139,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 +148,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,6 +1,6 @@
 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_platforms('packaging_timeout 666') do
@@ -9,13 +9,11 @@ describe HybridPlatformsConductor::Deployer do
     end
 
     it 'declares log plugins to be used' do
-      with_test_platforms(
-        { nodes: { 'node1' => {}, 'node2' => {} } },
-        false,
-        <<~EOS
+      with_platforms(
+        <<~EO_CONFIG
           send_logs_to %i[log_plugin_1 log_plugin_2]
           for_nodes('node2') { send_logs_to :log_plugin_3 }
-        EOS
+        EO_CONFIG
       ) do
         expect(test_config.deployment_logs).to eq [
           {
@@ -30,6 +28,26 @@ describe HybridPlatformsConductor::Deployer do
       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
+
   end
 
 end

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

@@ -1,36 +1,39 @@
 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 'checking log plugins usage' do
+    context 'when checking log plugins usage' do
 
       # Prepare the test platform with test log plugins
       #
       # Parameters::
-      # * *platforms_info* (Hash): The platforms info [default = {}]
-      # * *as_git* (Boolean): As a git repository? [default = false]
-      # * *additional_config* (String): Additional config [default = 'send_logs_to :test_log']
-      def with_test_platform_for_deploy_tests(platforms_info = {}, as_git = false, additional_config = 'send_logs_to :test_log')
-        with_test_platform(platforms_info, false, additional_config) do
-          yield
-        end
+      # * *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
 
       it 'deploys correct logs information on 1 node' do
-        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) 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([
+            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 [
               {
@@ -53,17 +56,22 @@ describe HybridPlatformsConductor::Deployer do
       end
 
       it 'deploys correct logs information on several nodes' do
-        with_test_platform_for_deploy_tests({ nodes: {
-          'node1' => { services: %w[service1] },
-          'node2' => { services: %w[service2] }
-        } }, true) do
+        with_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([
+            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
@@ -75,7 +83,7 @@ describe HybridPlatformsConductor::Deployer do
                   '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', '']
@@ -115,11 +123,11 @@ describe HybridPlatformsConductor::Deployer do
       end
 
       it 'deploys correct logs information on 1 node even when there is a failing deploy' do
-        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
+        with_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([
+            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(
@@ -132,7 +140,7 @@ describe HybridPlatformsConductor::Deployer do
               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 [
               {
@@ -155,14 +163,14 @@ describe HybridPlatformsConductor::Deployer do
       end
 
       it 'gets deployment info from log plugins' do
-        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }) do |repository|
-          expect_actions_executor_runs([
+        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_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.deployment_info_from('node')).to eq(
             'node' => {
               deployment_info: { user: 'test_user' },
@@ -189,7 +197,7 @@ describe HybridPlatformsConductor::Deployer do
       end
 
       it 'gets deployment info from log plugins not having actions_to_read_logs' do
-        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }, false, 'send_logs_to :test_log_no_read') do |repository|
+        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' },