hybrid_platforms_conductor 32.17.0 → 33.0.2

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

@@ -0,0 +1,223 @@
+describe HybridPlatformsConductor::Deployer do
+
+  context 'when checking log plugins' do
+
+    context 'with remote_fs' do
+
+      # Return a test platform ready to test the remote_fs log plugin
+      #
+      # Parameters::
+      # * *block* (Proc): Code called with platform prepared
+      def with_test_platform_for_remote_fs(&block)
+        with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, additional_config: 'send_logs_to :remote_fs', &block)
+      end
+
+      it 'returns actions to save logs' do
+        with_test_platform_for_remote_fs do
+          with_connections_mocked_on ['node'] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect_services_handler_to_deploy('node' => %w[service1 service2])
+            expect_actions_executor_runs [
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc do |actions_per_nodes|
+                expect_actions_to_deploy_on(
+                  actions_per_nodes,
+                  'node',
+                  mocked_result: { 'node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'] }
+                )
+              end,
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
+              # Third run, we expect logs to be uploaded on the node
+              proc do |actions_per_nodes|
+                expect(actions_per_nodes['node'].size).to eq 3
+                expect(actions_per_nodes['node'][0].keys.sort).to eq %i[ruby remote_bash].sort
+                expect(actions_per_nodes['node'][0][:remote_bash]).to eq 'sudo -u root mkdir -p /var/log/deployments && sudo -u root chmod 600 /var/log/deployments'
+                expect(actions_per_nodes['node'][1].keys.sort).to eq %i[scp].sort
+                expect(actions_per_nodes['node'][1][:scp].delete(:sudo)).to eq true
+                expect(actions_per_nodes['node'][1][:scp].delete(:owner)).to eq 'root'
+                expect(actions_per_nodes['node'][1][:scp].delete(:group)).to eq 'root'
+                expect(actions_per_nodes['node'][1][:scp].size).to eq 1
+                tmp_log_file = actions_per_nodes['node'][1][:scp].first[0]
+                expect(actions_per_nodes['node'][1][:scp].first[1]).to eq '/var/log/deployments'
+                expect(actions_per_nodes['node'][2].keys.sort).to eq %i[ruby remote_bash].sort
+                expect(actions_per_nodes['node'][2][:remote_bash]).to eq "sudo -u root chmod 600 /var/log/deployments/#{File.basename(tmp_log_file)}"
+                # Call the Ruby codes to be tested
+                actions_per_nodes['node'][0][:ruby].call
+                expect(File.exist?(tmp_log_file)).to eq true
+                file_content_regexp = Regexp.new <<~EOREGEXP
+                  repo_name_0: platform
+                  commit_id_0: 123456
+                  commit_message_0: Test commit for node: service1, service2
+                  date: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}
+                  user: test_user
+                  debug: No
+                  services: service1, service2
+                  exit_status: 0
+                  ===== STDOUT =====
+                  Deploy successful stdout
+                  ===== STDERR =====
+                  Deploy successful stderr
+                EOREGEXP
+                expect(File.read(tmp_log_file)).to match file_content_regexp
+                actions_per_nodes['node'][2][:ruby].call
+                # Check temporary log file gets deleted for security reasons
+                expect(File.exist?(tmp_log_file)).to eq false
+              end
+            ]
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'])
+          end
+        end
+      end
+
+      it 'returns actions to save logs using root' do
+        with_test_platform_for_remote_fs do
+          with_connections_mocked_on ['node'] do
+            test_actions_executor.connector(:ssh).ssh_user = 'root'
+            expect_services_handler_to_deploy('node' => %w[service1 service2])
+            expect_actions_executor_runs [
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc do |actions_per_nodes|
+                expect_actions_to_deploy_on(
+                  actions_per_nodes,
+                  'node',
+                  sudo: nil,
+                  mocked_result: { 'node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'] }
+                )
+              end,
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node', sudo: nil) },
+              # Third run, we expect logs to be uploaded on the node
+              proc do |actions_per_nodes|
+                expect(actions_per_nodes['node'].size).to eq 3
+                expect(actions_per_nodes['node'][0].keys.sort).to eq %i[ruby remote_bash].sort
+                expect(actions_per_nodes['node'][0][:remote_bash]).to eq 'mkdir -p /var/log/deployments && chmod 600 /var/log/deployments'
+                expect(actions_per_nodes['node'][1].keys.sort).to eq %i[scp].sort
+                expect(actions_per_nodes['node'][1][:scp].delete(:sudo)).to eq false
+                expect(actions_per_nodes['node'][1][:scp].delete(:owner)).to eq 'root'
+                expect(actions_per_nodes['node'][1][:scp].delete(:group)).to eq 'root'
+                expect(actions_per_nodes['node'][1][:scp].size).to eq 1
+                tmp_log_file = actions_per_nodes['node'][1][:scp].first[0]
+                expect(actions_per_nodes['node'][1][:scp].first[1]).to eq '/var/log/deployments'
+                expect(actions_per_nodes['node'][2].keys.sort).to eq %i[ruby remote_bash].sort
+                expect(actions_per_nodes['node'][2][:remote_bash]).to eq "chmod 600 /var/log/deployments/#{File.basename(tmp_log_file)}"
+                # Call the Ruby codes to be tested
+                actions_per_nodes['node'][0][:ruby].call
+                expect(File.exist?(tmp_log_file)).to eq true
+                file_content_regexp = Regexp.new <<~EOREGEXP
+                  repo_name_0: platform
+                  commit_id_0: 123456
+                  commit_message_0: Test commit for node: service1, service2
+                  date: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}
+                  user: root
+                  debug: No
+                  services: service1, service2
+                  exit_status: 0
+                  ===== STDOUT =====
+                  Deploy successful stdout
+                  ===== STDERR =====
+                  Deploy successful stderr
+                EOREGEXP
+                expect(File.read(tmp_log_file)).to match file_content_regexp
+                actions_per_nodes['node'][2][:ruby].call
+                # Check temporary log file gets deleted for security reasons
+                expect(File.exist?(tmp_log_file)).to eq false
+              end
+            ]
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful stdout', 'Deploy successful stderr'])
+          end
+        end
+      end
+
+      it 'reads logs' do
+        with_test_platform_for_remote_fs do
+          expect_actions_executor_runs [
+            # Expect the actions to get log files
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes).to eq('node' => [{ remote_bash: 'sudo -u root cat /var/log/deployments/`sudo -u root ls -t /var/log/deployments/ | head -1`' }])
+              { 'node' => [0, <<~EO_STDOUT, ''] }
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                diff_files_0: file1, file2, file3
+                date: 2017-11-23 18:43:01
+                user: test_user
+                debug: Yes
+                services: service1, service2, service3
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EO_STDOUT
+            end
+          ]
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: {
+                repo_name_0: 'platform',
+                commit_id_0: '123456',
+                commit_message_0: 'Test commit for node: service1, service2',
+                diff_files_0: %w[file1 file2 file3],
+                date: Time.parse('2017-11-23 18:43:01 UTC'),
+                debug: true,
+                user: 'test_user'
+              },
+              exit_status: 0,
+              services: %w[service1 service2 service3],
+              stderr: 'Deploy successful stderr',
+              stdout: 'Deploy successful stdout'
+            }
+          )
+        end
+      end
+
+      it 'reads logs using root' do
+        with_test_platform_for_remote_fs do
+          test_actions_executor.connector(:ssh).ssh_user = 'root'
+          expect_actions_executor_runs [
+            # Expect the actions to get log files
+            proc do |actions_per_nodes|
+              expect(actions_per_nodes).to eq('node' => [{ remote_bash: 'cat /var/log/deployments/`ls -t /var/log/deployments/ | head -1`' }])
+              { 'node' => [0, <<~EO_STDOUT, ''] }
+                repo_name_0: platform
+                commit_id_0: 123456
+                commit_message_0: Test commit for node: service1, service2
+                diff_files_0: file1, file2, file3
+                date: 2017-11-23 18:43:01
+                user: test_user
+                debug: Yes
+                services: service1, service2, service3
+                exit_status: 0
+                ===== STDOUT =====
+                Deploy successful stdout
+                ===== STDERR =====
+                Deploy successful stderr
+              EO_STDOUT
+            end
+          ]
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: {
+                repo_name_0: 'platform',
+                commit_id_0: '123456',
+                commit_message_0: 'Test commit for node: service1, service2',
+                diff_files_0: %w[file1 file2 file3],
+                date: Time.parse('2017-11-23 18:43:01 UTC'),
+                debug: true,
+                user: 'test_user'
+              },
+              exit_status: 0,
+              services: %w[service1 service2 service3],
+              stderr: 'Deploy successful stderr',
+              stdout: 'Deploy successful stdout'
+            }
+          )
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,29 +1,27 @@
 describe HybridPlatformsConductor::Deployer do
 
-  context 'checking parsing output of deployments' do
+  context 'when checking parsing output of deployments' do
 
     it 'returns tasks of deployment logs' do
-      with_test_platform do
-        expect(test_services_handler).to receive(:parse_deploy_output).with('stdout', 'stderr') do
-          [
-            {
-              node: 'node',
-              service: 'service',
-              check: false,
-              tasks: [
-                {
-                  name: 'Task1',
-                  status: :identical
-                },
-                {
-                  name: 'Task2',
-                  status: :changed,
-                  diffs: 'Diffs for Task2'
-                }
-              ]
-            }
-          ]
-        end
+      with_test_platform({}) do
+        expect(test_services_handler).to receive(:parse_deploy_output).with('stdout', 'stderr').and_return [
+          {
+            node: 'node',
+            service: 'service',
+            check: false,
+            tasks: [
+              {
+                name: 'Task1',
+                status: :identical
+              },
+              {
+                name: 'Task2',
+                status: :changed,
+                diffs: 'Diffs for Task2'
+              }
+            ]
+          }
+        ]
         expect(test_deployer.parse_deploy_output('node', 'stdout', 'stderr')).to eq [
           {
             name: 'Task1',
@@ -39,43 +37,41 @@ describe HybridPlatformsConductor::Deployer do
     end
 
     it 'returns tasks of deployment logs from several services deployments' do
-      with_test_platform do
-        expect(test_services_handler).to receive(:parse_deploy_output).with('stdout', 'stderr') do
-          [
-            {
-              node: 'node1',
-              service: 'service1',
-              check: false,
-              tasks: [
-                {
-                  name: 'Task1',
-                  status: :identical
-                },
-                {
-                  name: 'Task2',
-                  status: :changed,
-                  diffs: 'Diffs for Task2'
-                }
-              ]
-            },
-            {
-              node: 'node2',
-              service: 'service2',
-              check: false,
-              tasks: [
-                {
-                  name: 'Task3',
-                  status: :identical
-                },
-                {
-                  name: 'Task4',
-                  status: :changed,
-                  diffs: 'Diffs for Task4'
-                }
-              ]
-            }
-          ]
-        end
+      with_test_platform({}) do
+        expect(test_services_handler).to receive(:parse_deploy_output).with('stdout', 'stderr').and_return [
+          {
+            node: 'node1',
+            service: 'service1',
+            check: false,
+            tasks: [
+              {
+                name: 'Task1',
+                status: :identical
+              },
+              {
+                name: 'Task2',
+                status: :changed,
+                diffs: 'Diffs for Task2'
+              }
+            ]
+          },
+          {
+            node: 'node2',
+            service: 'service2',
+            check: false,
+            tasks: [
+              {
+                name: 'Task3',
+                status: :identical
+              },
+              {
+                name: 'Task4',
+                status: :changed,
+                diffs: 'Diffs for Task4'
+              }
+            ]
+          }
+        ]
         expect(test_deployer.parse_deploy_output('node', 'stdout', 'stderr')).to eq [
           {
             name: 'Task1',

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

@@ -3,48 +3,40 @@ require 'securerandom'
 
 describe HybridPlatformsConductor::Deployer do
 
-  context 'checking provisioning' do
+  context 'when checking provisioning' do
 
     it 'gives a new test instance ready to be used in place of the node' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          block.call
-        end
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
         provisioner = nil
         test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
           expect(sub_test_deployer.local_environment).to eq true
           provisioner = test_instance
           expect(test_instance.node).to eq 'node'
-          expect(test_instance.environment).to match /^#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+$/
+          expect(test_instance.environment).to match(/^#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+$/)
         end
         expect(provisioner.actions).to eq %i[create state state start state ip ip stop state destroy]
       end
     end
 
     it 'gives a new test instance ready to be used in place of the node, using the timeout given by the provisioner' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
         HybridPlatformsConductorTest::TestProvisioner.mocked_default_timeout = 666
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 666 }) do |&block|
-          block.call
-        end
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 666 }).and_yield
         provisioner = nil
         test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
           expect(sub_test_deployer.local_environment).to eq true
           provisioner = test_instance
           expect(test_instance.node).to eq 'node'
-          expect(test_instance.environment).to match /^#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+$/
+          expect(test_instance.environment).to match(/^#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+$/)
         end
         expect(provisioner.actions).to eq %i[create state state start state ip ip stop state destroy]
       end
@@ -58,26 +50,24 @@ describe HybridPlatformsConductor::Deployer do
             'node2' => { meta: { host_ip: '192.168.42.2', ssh_session_exec: false } }
           }
         },
-        false,
-        '
+        additional_config: <<~'EO_CONFIG'
           for_nodes(%w[node1 node2]) do
             transform_ssh_connection do |node, connection, connection_user, gateway, gateway_user|
               ["#{connection}_#{node}", "#{connection_user}_#{node}", "#{gateway}_#{node}", "#{gateway_user}_#{node}"]
             end
           end
-        '
-      ) do |repository|
+        EO_CONFIG
+      ) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          block.call
-        end
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
         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
-          ssh_transforms = test_instance.instance_eval { @config.ssh_connection_transforms }
+          sub_nodes_handler = sub_test_deployer.instance_variable_get(:@nodes_handler)
+          expect(sub_nodes_handler.get_ssh_session_exec_of('node1')).to eq true
+          expect(sub_nodes_handler.get_ssh_session_exec_of('node2')).to eq false
+          ssh_transforms = test_instance.instance_variable_get(:@config).ssh_connection_transforms
           expect(ssh_transforms.size).to eq 1
           expect(ssh_transforms[0][:nodes_selectors_stack]).to eq [%w[node2]]
         end
@@ -92,17 +82,16 @@ describe HybridPlatformsConductor::Deployer do
             'node2' => { meta: { local_node: true } }
           }
         }
-      ) do |repository|
+      ) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          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_local_node_of('node1') }).to eq false
-          expect(sub_test_deployer.instance_eval { @nodes_handler.get_local_node_of('node2') }).to eq true
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
+        test_deployer.with_test_provisioned_instance(:test_provisioner, 'node1', environment: 'hpc_testing_provisioner') do |sub_test_deployer|
+          sub_nodes_handler = sub_test_deployer.instance_variable_get(:@nodes_handler)
+          expect(sub_nodes_handler.get_local_node_of('node1')).to eq false
+          expect(sub_nodes_handler.get_local_node_of('node2')).to eq true
         end
       end
     end
@@ -115,22 +104,19 @@ describe HybridPlatformsConductor::Deployer do
             'node2' => { meta: { host_ip: '192.168.42.2' } }
           }
         },
-        false,
-        '
+        additional_config: <<~'EO_CONFIG'
           for_nodes(%w[node1 node2]) do
             sudo_for { |user| "other_sudo --user #{user}" }
           end
-        '
-      ) do |repository|
+        EO_CONFIG
+      ) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          block.call
-        end
-        test_deployer.with_test_provisioned_instance(:test_provisioner, 'node1', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
-          sudo_procs = test_instance.instance_eval { @config.sudo_procs }
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
+        test_deployer.with_test_provisioned_instance(:test_provisioner, 'node1', environment: 'hpc_testing_provisioner') do |_sub_test_deployer, test_instance|
+          sudo_procs = test_instance.instance_variable_get(:@config).sudo_procs
           expect(sudo_procs.size).to eq 1
           expect(sudo_procs[0][:nodes_selectors_stack]).to eq [%w[node2]]
         end
@@ -138,16 +124,12 @@ describe HybridPlatformsConductor::Deployer do
     end
 
     it 'does not destroy instances when asked to reuse' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          block.call
-        end
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
         provisioner = nil
         test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner', reuse_instance: true) do |sub_test_deployer, test_instance|
           expect(sub_test_deployer.local_environment).to eq true
@@ -160,16 +142,12 @@ describe HybridPlatformsConductor::Deployer do
     end
 
     it 'reuses running instances when asked to reuse' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[running running running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
-          block.call
-        end
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }).and_yield
         provisioner = nil
         test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner', reuse_instance: true) do |sub_test_deployer, test_instance|
           expect(sub_test_deployer.local_environment).to eq true
@@ -182,34 +160,30 @@ describe HybridPlatformsConductor::Deployer do
     end
 
     it 'fails when the provisioner can\'t start' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created created exited exited]
         expect do
           test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
           end
-        end.to raise_error /\[ node\/#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+ \] - Instance fails to be in a state among \(running\) with timeout 1\. Currently in state exited/
+        end.to raise_error(%r{\[ node/#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+ \] - Instance fails to be in a state among \(running\) with timeout 1\. Currently in state exited})
       end
     end
 
     it 'fails when the provisioner can\'t have its SSH port opened' do
-      with_test_platform(
-        nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }
-      ) do |repository|
+      with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }) do
         register_plugins(:provisioner, { test_provisioner: HybridPlatformsConductorTest::TestProvisioner })
         File.write("#{test_config.hybrid_platforms_dir}/dummy_secrets.json", '{}')
         HybridPlatformsConductorTest::TestProvisioner.mocked_states = %i[created created running exited]
         HybridPlatformsConductorTest::TestProvisioner.mocked_ip = '172.17.0.1'
-        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do |&block|
+        expect(Socket).to receive(:tcp).with('172.17.0.1', 22, { connect_timeout: 1 }) do
           raise Errno::ETIMEDOUT, 'Timeout while reading from port 22'
         end
         expect do
           test_deployer.with_test_provisioned_instance(:test_provisioner, 'node', environment: 'hpc_testing_provisioner') do |sub_test_deployer, test_instance|
           end
-        end.to raise_error /\[ node\/#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+ \] - Instance fails to have port 22 opened with timeout 1\./
+        end.to raise_error(%r{\[ node/#{Regexp.escape(`whoami`.strip)}_hpc_testing_provisioner_\d+_\d+_\w+ \] - Instance fails to have port 22 opened with timeout 1\.})
       end
     end