hybrid_platforms_conductor 33.0.0 → 33.0.1

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

@@ -1,8 +1,25 @@
+# Specific test registered by the test platform handler
+class SpecificPlatformHandlerTest < HybridPlatformsConductor::Test
+
+  class << self
+
+    attr_accessor :run
+
+  end
+  @run = false
+
+  def test
+    SpecificPlatformHandlerTest.run = true
+  end
+
+end
+
 describe HybridPlatformsConductor::TestsRunner do
 
   it 'executes all tests when no test is selected' do
-    with_test_platform do
-      register_test_plugins(test_tests_runner,
+    with_test_platform({}) do
+      register_test_plugins(
+        test_tests_runner,
         global_test: HybridPlatformsConductorTest::TestPlugins::Global,
         global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
       )
@@ -12,8 +29,9 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'executes all tests when all tests are selected' do
-    with_test_platform do
-      register_test_plugins(test_tests_runner,
+    with_test_platform({}) do
+      register_test_plugins(
+        test_tests_runner,
         global_test: HybridPlatformsConductorTest::TestPlugins::Global,
         global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
       )
@@ -24,7 +42,7 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'returns 1 when tests are failing' do
-    with_test_platform do
+    with_test_platform({}) do
       register_test_plugins(test_tests_runner, global_test: HybridPlatformsConductorTest::TestPlugins::Global)
       HybridPlatformsConductorTest::TestPlugins::Global.fail = true
       expect(test_tests_runner.run_tests([])).to eq 1
@@ -33,9 +51,12 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'returns 0 when tests are failing as expected' do
-    with_test_platform({}, false, '
-      expect_tests_to_fail(:platform_test, \'Expected failure\')
-    ') do
+    with_test_platform(
+      {},
+      additional_config: <<~'EO_CONFIG'
+        expect_tests_to_fail(:platform_test, 'Expected failure')
+      EO_CONFIG
+    ) do
       register_test_plugins(test_tests_runner, platform_test: HybridPlatformsConductorTest::TestPlugins::Platform)
       HybridPlatformsConductorTest::TestPlugins::Platform.fail_for = ['platform']
       expect(test_tests_runner.run_tests([])).to eq 0
@@ -44,11 +65,14 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'returns 0 when tests are failing as expected on a given node' do
-    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {} } }, false, '
-      for_nodes(\'node2\') do
-        expect_tests_to_fail(:node_test, \'Expected failure\')
-      end
-    ') do
+    with_test_platform(
+      { nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {} } },
+      additional_config: <<~'EO_CONFIG'
+        for_nodes('node2') do
+          expect_tests_to_fail(:node_test, 'Expected failure')
+        end
+      EO_CONFIG
+    ) do
       register_test_plugins(test_tests_runner, node_test: HybridPlatformsConductorTest::TestPlugins::Node)
       HybridPlatformsConductorTest::TestPlugins::Node.fail_for = { node_test: ['node2'] }
       expect(test_tests_runner.run_tests(%w[node1 node2 node3])).to eq 0
@@ -57,9 +81,12 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'returns 1 when tests are succeeding but were expected to fail' do
-    with_test_platform({}, false, '
-      expect_tests_to_fail(:platform_test, \'Expected failure\')
-    ') do
+    with_test_platform(
+      {},
+      additional_config: <<~'EO_CONFIG'
+        expect_tests_to_fail(:platform_test, 'Expected failure')
+      EO_CONFIG
+    ) do
       register_test_plugins(test_tests_runner, platform_test: HybridPlatformsConductorTest::TestPlugins::Platform)
       expect(test_tests_runner.run_tests([])).to eq 1
       expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs).to eq [[:platform_test, 'platform']]
@@ -67,11 +94,14 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'returns 1 when extra expected failures have not been tested when running all tests' do
-    with_test_platform({ nodes: { 'another_node' => {} } }, false, '
-      for_nodes(\'another_node\') do
-        expect_tests_to_fail(:platform_test, \'Expected failure\')
-      end
-    ') do
+    with_test_platform(
+      { nodes: { 'another_node' => {} } },
+      additional_config: <<~'EO_CONFIG'
+        for_nodes('another_node') do
+          expect_tests_to_fail(:platform_test, 'Expected failure')
+        end
+      EO_CONFIG
+    ) do
       register_test_plugins(test_tests_runner, platform_test: HybridPlatformsConductorTest::TestPlugins::Platform)
       expect(test_tests_runner.run_tests([])).to eq 1
       expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs).to eq [[:platform_test, 'platform']]
@@ -79,11 +109,13 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'fails when expected failures reference missing nodes' do
-    with_test_platform({ nodes: { 'node' => {} } }, false, '
-        for_nodes(\'missing_node\') do
-          expect_tests_to_fail(:node_test, \'Expected failure\')
+    with_test_platform(
+      { nodes: { 'node' => {} } },
+      additional_config: <<~'EO_CONFIG'
+        for_nodes('missing_node') do
+          expect_tests_to_fail(:node_test, 'Expected failure')
         end
-      '
+      EO_CONFIG
     ) do
       register_test_plugins(test_tests_runner, node_test: HybridPlatformsConductorTest::TestPlugins::Node)
       expect { test_tests_runner.run_tests([{ all: true }]) }.to raise_error 'Unknown nodes: missing_node'
@@ -91,7 +123,7 @@ describe HybridPlatformsConductor::TestsRunner do
   end
 
   it 'fails when we ask for an unknown test' do
-    with_test_platform do
+    with_test_platform({}) do
       register_test_plugins(test_tests_runner, global_test: HybridPlatformsConductorTest::TestPlugins::Global)
       test_tests_runner.tests = [:global_test_2]
       expect { test_tests_runner.run_tests([]) }.to raise_error(RuntimeError, 'Unknown test names: global_test_2')
@@ -100,8 +132,10 @@ describe HybridPlatformsConductor::TestsRunner do
 
   it 'executes different tests levels if 1 plugin defines them' do
     with_test_platforms(
-      'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
-      'platform2' => { nodes: { 'node21' => {}, 'node22' => {} } }
+      {
+        'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
+        'platform2' => { nodes: { 'node21' => {}, 'node22' => {} } }
+      }
     ) do
       register_test_plugins(test_tests_runner, several_tests: HybridPlatformsConductorTest::TestPlugins::SeveralChecks)
       # Mock the Actions Executor and Deployer expected calls
@@ -128,23 +162,23 @@ describe HybridPlatformsConductor::TestsRunner do
             'echo "$?"'
           ]
         end
-        Hash[node_suffixes.map do |node_suffix|
+        node_suffixes.map do |node_suffix|
           [
             "node#{node_suffix}",
             [
               0,
-              <<~EOS,
+              <<~EO_STDOUT,
                 ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                 stdout#{node_suffix}
                 0
-              EOS
-              <<~EOS
+              EO_STDOUT
+              <<~EO_STDERR
                 ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                 stderr#{node_suffix}
-              EOS
+              EO_STDERR
             ]
           ]
-        end]
+        end.to_h
       end])
       # Run everything
       test_tests_runner.tests = [:several_tests]
@@ -169,22 +203,8 @@ describe HybridPlatformsConductor::TestsRunner do
     end
   end
 
-  # Specific test registered by the test platform handler
-  class SpecificPlatformHandlerTest < HybridPlatformsConductor::Test
-
-    class << self
-      attr_accessor :run
-    end
-    @run = false
-
-    def test
-      SpecificPlatformHandlerTest.run = true
-    end
-
-  end
-
   it 'executes tests defined by a platform handler' do
-    with_test_platform(tests: { specific_platform_handler_test: SpecificPlatformHandlerTest }) do
+    with_test_platform({ tests: { specific_platform_handler_test: SpecificPlatformHandlerTest } }) do
       test_tests_runner.tests = [:specific_platform_handler_test]
       expect(test_tests_runner.run_tests([])).to eq 0
       expect(SpecificPlatformHandlerTest.run).to eq true

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

@@ -1,6 +1,6 @@
 describe HybridPlatformsConductor::TestsRunner do
 
-  context 'checking global tests execution' do
+  context 'when checking global tests execution' do
 
     # Prepare the test platform with test plugins
     #
@@ -8,7 +8,8 @@ describe HybridPlatformsConductor::TestsRunner do
     # * *platforms_info* (Hash): The platforms info [default: {}]
     def with_test_platform_for_global_tests(platforms_info: {})
       with_test_platform(platforms_info) do
-        register_test_plugins(test_tests_runner,
+        register_test_plugins(
+          test_tests_runner,
           global_test: HybridPlatformsConductorTest::TestPlugins::Global,
           global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
         )
@@ -26,7 +27,7 @@ describe HybridPlatformsConductor::TestsRunner do
 
     it 'executes several global tests' do
       with_test_platform_for_global_tests do
-        test_tests_runner.tests = [:global_test, :global_test_2]
+        test_tests_runner.tests = %i[global_test global_test_2]
         expect(test_tests_runner.run_tests([])).to eq 0
         expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 2
       end

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

@@ -1,6 +1,6 @@
 describe HybridPlatformsConductor::TestsRunner do
 
-  context 'checking node tests on check-node results' do
+  context 'when checking node tests on check-node results' do
 
     # Prepare the test platform with test plugins
     #
@@ -8,10 +8,13 @@ describe HybridPlatformsConductor::TestsRunner do
     # * Proc: Code called with the platform setup
     def with_test_platform_for_node_check_tests
       with_test_platforms(
-        'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
-        'platform2' => { nodes: { 'node21' => {}, 'node22' => {} }, platform_type: :test2 }
+        {
+          'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
+          'platform2' => { nodes: { 'node21' => {}, 'node22' => {} }, platform_type: :test_2 }
+        }
       ) do
-        register_test_plugins(test_tests_runner,
+        register_test_plugins(
+          test_tests_runner,
           node_check_test: HybridPlatformsConductorTest::TestPlugins::NodeCheck,
           node_check_test_2: HybridPlatformsConductorTest::TestPlugins::NodeCheck
         )
@@ -61,7 +64,7 @@ describe HybridPlatformsConductor::TestsRunner do
 
     it 'executes check node tests once per node even if there are several tests using check reports' do
       with_test_platform_for_node_check_tests do
-        test_tests_runner.tests = [:node_check_test, :node_check_test_2]
+        test_tests_runner.tests = %i[node_check_test node_check_test_2]
         expect(test_deployer).to receive(:deploy_on).with(%w[node11 node12 node21 node22]).once do
           expect(test_deployer.use_why_run).to eq true
           {

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

@@ -1,6 +1,6 @@
 describe HybridPlatformsConductor::TestsRunner do
 
-  context 'checking node tests execution' do
+  context 'when checking node tests execution' do
 
     # Prepare the test platform with test plugins
     #
@@ -8,10 +8,13 @@ describe HybridPlatformsConductor::TestsRunner do
     # * Proc: Code called with the platform setup
     def with_test_platform_for_node_tests
       with_test_platforms(
-        'platform1' => { nodes: { 'node11' => {}, 'node12' => {}, 'node13' => {} } },
-        'platform2' => { nodes: { 'node21' => {}, 'node22' => {}, 'node23' => {} }, platform_type: :test2 }
+        {
+          'platform1' => { nodes: { 'node11' => {}, 'node12' => {}, 'node13' => {} } },
+          'platform2' => { nodes: { 'node21' => {}, 'node22' => {}, 'node23' => {} }, platform_type: :test_2 }
+        }
       ) do
-        register_test_plugins(test_tests_runner,
+        register_test_plugins(
+          test_tests_runner,
           node_test: HybridPlatformsConductorTest::TestPlugins::Node,
           node_test_2: HybridPlatformsConductorTest::TestPlugins::Node
         )
@@ -47,7 +50,7 @@ describe HybridPlatformsConductor::TestsRunner do
 
     it 'executes several node tests' do
       with_test_platform_for_node_tests do
-        test_tests_runner.tests = [:node_test, :node_test_2]
+        test_tests_runner.tests = %i[node_test node_test_2]
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
         expect(HybridPlatformsConductorTest::TestPlugins::Node.runs.sort).to eq [
           [:node_test, 'node11'],

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

@@ -1,6 +1,6 @@
 describe HybridPlatformsConductor::TestsRunner do
 
-  context 'checking connection node tests execution' do
+  context 'when checking connection node tests execution' do
 
     # Prepare the test platform with test plugins
     #
@@ -8,10 +8,13 @@ describe HybridPlatformsConductor::TestsRunner do
     # * Proc: Code called with the platform setup
     def with_test_platform_for_node_connection_tests
       with_test_platforms(
-        'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
-        'platform2' => { nodes: { 'node21' => {}, 'node22' => {} }, platform_type: :test2 }
+        {
+          'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
+          'platform2' => { nodes: { 'node21' => {}, 'node22' => {} }, platform_type: :test_2 }
+        }
       ) do
-        register_test_plugins(test_tests_runner,
+        register_test_plugins(
+          test_tests_runner,
           node_ssh_test: HybridPlatformsConductorTest::TestPlugins::NodeSsh,
           node_ssh_test_2: HybridPlatformsConductorTest::TestPlugins::NodeSsh
         )
@@ -40,23 +43,23 @@ describe HybridPlatformsConductor::TestsRunner do
           'echo "$?"'
         ]
       end
-      Hash[node_suffixes.map do |node_suffix|
+      node_suffixes.map do |node_suffix|
         [
           "node#{node_suffix}",
           [
             0,
-            <<~EOS,
+            <<~EO_STDOUT,
               ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
               stdout#{node_suffix}
               #{fails_on.include?(node_suffix) ? 1 : 0}
-            EOS
-            <<~EOS,
+            EO_STDOUT
+            <<~EO_STDERR
               ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
               stderr#{node_suffix}
-            EOS
+            EO_STDERR
           ]
         ]
-      end]
+      end.to_h
     end
 
     it 'executes SSH node tests once per node with the correct command' do
@@ -126,34 +129,34 @@ describe HybridPlatformsConductor::TestsRunner do
               'echo "$?"',
               'echo \'===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\'',
               '>&2 echo \'===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\'',
-              "test2_node#{node_suffix}.sh",
+              "test_2_node#{node_suffix}.sh",
               'echo "$?"'
             ]
           end
-          Hash[node_suffixes.map do |node_suffix|
+          node_suffixes.map do |node_suffix|
             [
               "node#{node_suffix}",
               [
                 0,
-                <<~EOS,
+                <<~EO_STDOUT,
                   ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                   stdout#{node_suffix}
                   0
                   ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                   stdout#{node_suffix}_2
                   0
-                EOS
-                <<~EOS
+                EO_STDOUT
+                <<~EO_STDERR
                   ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                   stderr#{node_suffix}
                   ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
                   stderr#{node_suffix}_2
-                EOS
+                EO_STDERR
               ]
             ]
-          end]
+          end.to_h
         end])
-        test_tests_runner.tests = [:node_ssh_test, :node_ssh_test_2]
+        test_tests_runner.tests = %i[node_ssh_test node_ssh_test_2]
         ssh_executions = []
         HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = {
           node_ssh_test: {
@@ -163,10 +166,10 @@ describe HybridPlatformsConductor::TestsRunner do
             'node22' => { 'test_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
           },
           node_ssh_test_2: {
-            'node11' => { 'test2_node11.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node11', stdout, stderr, exit_code] } },
-            'node12' => { 'test2_node12.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node12', stdout, stderr, exit_code] } },
-            'node21' => { 'test2_node21.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node21', stdout, stderr, exit_code] } },
-            'node22' => { 'test2_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
+            'node11' => { 'test_2_node11.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node11', stdout, stderr, exit_code] } },
+            'node12' => { 'test_2_node12.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node12', stdout, stderr, exit_code] } },
+            'node21' => { 'test_2_node21.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node21', stdout, stderr, exit_code] } },
+            'node22' => { 'test_2_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
           }
         }
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
@@ -193,7 +196,7 @@ describe HybridPlatformsConductor::TestsRunner do
           'node12' => { 'test_node12.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node12', stdout, stderr, exit_code] } },
           'node21' => { 'test_node21.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node21', stdout, stderr, exit_code] } },
           'node22' => { 'test_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
-        }}
+        } }
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 1
         expect(ssh_executions.sort).to eq [
           ['node11', ['stdout11'], ['stderr11'], 0],
@@ -211,10 +214,10 @@ describe HybridPlatformsConductor::TestsRunner do
         ssh_executions = []
         HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = { node_ssh_test: {
           'node11' => { 'test_node11.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node11', stdout, stderr, exit_code] } },
-          'node12' => { 'test_node12.sh' => proc { |stdout, stderr, exit_code| raise 'Failure on this node' } },
+          'node12' => { 'test_node12.sh' => proc { raise 'Failure on this node' } },
           'node21' => { 'test_node21.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node21', stdout, stderr, exit_code] } },
           'node22' => { 'test_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
-        }}
+        } }
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 1
         expect(ssh_executions.sort).to eq [
           ['node11', ['stdout11'], ['stderr11'], 0],
@@ -233,7 +236,7 @@ describe HybridPlatformsConductor::TestsRunner do
         HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = { node_ssh_test: {
           'node12' => { 'test_node12.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node12', stdout, stderr, exit_code] } },
           'node22' => { 'test_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
-        }}
+        } }
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
         expect(ssh_executions.sort).to eq [
           ['node12', ['stdout12'], ['stderr12'], 0],
@@ -253,7 +256,7 @@ describe HybridPlatformsConductor::TestsRunner do
           'node12' => { 'test_node12.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node12', stdout, stderr, exit_code] } },
           'node21' => { 'test_node21.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node21', stdout, stderr, exit_code] } },
           'node22' => { 'test_node22.sh' => proc { |stdout, stderr, exit_code| ssh_executions << ['node22', stdout, stderr, exit_code] } }
-        }}
+        } }
         expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
         expect(test_tests_runner.max_threads_connection_on_nodes).to eq 43
         expect(ssh_executions.sort).to eq [