hybrid_platforms_conductor 32.3.6

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

@@ -0,0 +1,257 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking connection node tests execution' do
+
+    # Prepare the test platform with test plugins
+    #
+    # Parameters::
+    # * 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 }
+      ) do
+        register_test_plugins(test_tests_runner,
+          node_ssh_test: HybridPlatformsConductorTest::TestPlugins::NodeSsh,
+          node_ssh_test_2: HybridPlatformsConductorTest::TestPlugins::NodeSsh
+        )
+        yield
+      end
+    end
+
+    # Expect a given set of actions to execute test commands on a given set of nodes
+    #
+    # Parameters::
+    # * *actions* (Object): Actions
+    # * *node_suffixes* (Array<String>): The node suffixes
+    # * *fails_on* (Array<String>): The node suffixes on which we expect to fail [default: []]
+    # Result::
+    # * Hash<String, [Integer or Symbol, String, String] >: Expected result of those expected actions
+    def expect_actions_to_test_nodes(actions, node_suffixes, fails_on: [])
+      expect(actions.size).to eq node_suffixes.size
+      node_suffixes.each do |node_suffix|
+        node = "node#{node_suffix}"
+        expect(actions.key?(node)).to eq true
+        expect(actions[node].size).to eq 1
+        expect(actions[node][:remote_bash]).to eq [
+          '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 =====\'',
+          "test_node#{node_suffix}.sh",
+          'echo "$?"'
+        ]
+      end
+      Hash[node_suffixes.map do |node_suffix|
+        [
+          "node#{node_suffix}",
+          [
+            0,
+            <<~EOS,
+              ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
+              stdout#{node_suffix}
+              #{fails_on.include?(node_suffix) ? 1 : 0}
+            EOS
+            <<~EOS,
+              ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
+              stderr#{node_suffix}
+            EOS
+          ]
+        ]
+      end]
+    end
+
+    it 'executes SSH node tests once per node with the correct command' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[11 12 21 22]) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        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| 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(ssh_executions.sort).to eq [
+          ['node11', ['stdout11'], ['stderr11'], 0],
+          ['node12', ['stdout12'], ['stderr12'], 0],
+          ['node21', ['stdout21'], ['stderr21'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+    it 'executes SSH node tests only on specified nodes' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[12 22]) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        ssh_executions = []
+        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(%w[node12 node22])).to eq 0
+        expect(ssh_executions.sort).to eq [
+          ['node12', ['stdout12'], ['stderr12'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+    it 'executes several SSH node tests once per node with the correct command, grouping commands' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc do |actions|
+          node_suffixes = %w[11 12 21 22]
+          expect(actions.size).to eq node_suffixes.size
+          node_suffixes.each do |node_suffix|
+            node = "node#{node_suffix}"
+            expect(actions.key?(node)).to eq true
+            expect(actions[node].size).to eq 1
+            expect(actions[node][:remote_bash]).to eq [
+              '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 =====\'',
+              "test_node#{node_suffix}.sh",
+              '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",
+              'echo "$?"'
+            ]
+          end
+          Hash[node_suffixes.map do |node_suffix|
+            [
+              "node#{node_suffix}",
+              [
+                0,
+                <<~EOS,
+                  ===== 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
+                  ===== 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
+              ]
+            ]
+          end]
+        end])
+        test_tests_runner.tests = [:node_ssh_test, :node_ssh_test_2]
+        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| 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] } }
+          },
+          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] } }
+          }
+        }
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(ssh_executions.sort).to eq [
+          ['node11', ['stdout11'], ['stderr11'], 0],
+          ['node12', ['stdout12'], ['stderr12'], 0],
+          ['node21', ['stdout21'], ['stderr21'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0],
+          ['node11', ['stdout11_2'], ['stderr11_2'], 0],
+          ['node12', ['stdout12_2'], ['stderr12_2'], 0],
+          ['node21', ['stdout21_2'], ['stderr21_2'], 0],
+          ['node22', ['stdout22_2'], ['stderr22_2'], 0]
+        ].sort
+      end
+    end
+
+    it 'fails an SSH node test when the SSH command returns non zero exit code' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[11 12 21 22], fails_on: ['12']) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        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| 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],
+          ['node12', ['stdout12'], ['stderr12'], 1],
+          ['node21', ['stdout21'], ['stderr21'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+    it 'fails an SSH node test when the command test code raises an error' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[11 12 21 22], fails_on: ['12']) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        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' } },
+          '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],
+          ['node21', ['stdout21'], ['stderr21'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+    it 'executes SSH node tests only on valid nodes' do
+      with_test_platform_for_node_connection_tests do
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.only_on_nodes = %w[node12 node22]
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[12 22]) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        ssh_executions = []
+        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],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+    it 'executes SSH node tests in parallel' do
+      with_test_platform_for_node_connection_tests do
+        expect_actions_executor_runs([proc { |actions| expect_actions_to_test_nodes(actions, %w[11 12 21 22]) }])
+        test_tests_runner.tests = [:node_ssh_test]
+        test_tests_runner.max_threads_connection_on_nodes = 43
+        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| 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 [
+          ['node11', ['stdout11'], ['stderr11'], 0],
+          ['node12', ['stdout12'], ['stderr12'], 0],
+          ['node21', ['stdout21'], ['stderr21'], 0],
+          ['node22', ['stdout22'], ['stderr22'], 0]
+        ].sort
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,110 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking platform tests execution' do
+
+    # Prepare the test platform with test plugins
+    #
+    # Parameters::
+    # * Proc: Code called with the platform setup
+    def with_test_platform_for_platform_tests
+      with_test_platforms(
+        'platform1' => { nodes: { 'node11' => {}, 'node12' => {}, 'node13' => {} } },
+        'platform2' => { nodes: { 'node21' => {}, 'node22' => {}, 'node23' => {} }, platform_type: :test2 }
+      ) do
+        register_test_plugins(test_tests_runner,
+          platform_test: HybridPlatformsConductorTest::TestPlugins::Platform,
+          platform_test_2: HybridPlatformsConductorTest::TestPlugins::Platform
+        )
+        yield
+      end
+    end
+
+    it 'executes platform tests once per platform' do
+      with_test_platform_for_platform_tests do
+        test_tests_runner.tests = [:platform_test]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs.sort).to eq [[:platform_test, 'platform1'], [:platform_test, 'platform2']].sort
+      end
+    end
+
+    it 'executes several platform tests' do
+      with_test_platform_for_platform_tests do
+        test_tests_runner.tests = [:platform_test, :platform_test_2]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs.sort).to eq [
+          [:platform_test, 'platform1'],
+          [:platform_test, 'platform2'],
+          [:platform_test_2, 'platform1'],
+          [:platform_test_2, 'platform2']
+        ].sort
+      end
+    end
+
+    it 'executes platform tests only on valid platform types' do
+      with_test_platform_for_platform_tests do
+        test_tests_runner.tests = [:platform_test, :platform_test_2]
+        HybridPlatformsConductorTest::TestPlugins::Platform.only_on_platform_types = %i[test2]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs.sort).to eq [
+          [:platform_test, 'platform2'],
+          [:platform_test_2, 'platform2']
+        ].sort
+      end
+    end
+
+    it 'executes several platform tests in parallel' do
+      with_test_platform_for_platform_tests do
+        test_tests_runner.tests = [:platform_test, :platform_test_2]
+        test_tests_runner.max_threads_platforms = 4
+        HybridPlatformsConductorTest::TestPlugins::Platform.sleeps = {
+          platform_test: {
+            'platform1' => 0.8,
+            'platform2' => 0.4
+          },
+          platform_test_2: {
+            'platform1' => 0.6,
+            'platform2' => 0.2
+          }
+        }
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs).to eq [
+          [:platform_test_2, 'platform2'],
+          [:platform_test, 'platform2'],
+          [:platform_test_2, 'platform1'],
+          [:platform_test, 'platform1']
+        ]
+      end
+    end
+
+    it 'executes several platform tests in parallel with a limited number of threads' do
+      with_test_platform_for_platform_tests do
+        test_tests_runner.tests = [:platform_test, :platform_test_2]
+        test_tests_runner.max_threads_platforms = 2
+        HybridPlatformsConductorTest::TestPlugins::Platform.sleeps = {
+          platform_test: {
+            'platform1' => 0.8,
+            'platform2' => 0.4
+          },
+          platform_test_2: {
+            'platform1' => 0.6,
+            'platform2' => 0.3
+          }
+        }
+        # Here is the sequence:
+        # Thread 1: +-t1p1 0.8------------+-t2p2 0.3 ----+
+        # Thread 2: +-t1p2 0.4-+-t2p1 0.6-|----------+   |
+        #           |          |          |          |   |
+        # Time    : 0          0.4        0.8        1.0 1.1
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs).to eq [
+          [:platform_test, 'platform2'],
+          [:platform_test, 'platform1'],
+          [:platform_test_2, 'platform1'],
+          [:platform_test_2, 'platform2']
+        ]
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,367 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking reporting results of tests execution' do
+
+    # Setup a tests platform for the reports testing
+    #
+    # Parameters::
+    # * Proc: Code called with the platform setup
+    def with_test_platforms_for_reports_test
+      with_test_platforms(
+        'platform1' => { nodes: { 'node11' => {}, 'node12' => {} } },
+        'platform2' => { nodes: { 'node21' => {}, 'node22' => {} } }
+      ) do
+        register_tests_report_plugins(test_tests_runner, report: HybridPlatformsConductorTest::TestsReportPlugin)
+        register_test_plugins(test_tests_runner, {
+          global_test: HybridPlatformsConductorTest::TestPlugins::Global,
+          platform_test: HybridPlatformsConductorTest::TestPlugins::Platform,
+          node_test: HybridPlatformsConductorTest::TestPlugins::Node,
+          node_test_2: HybridPlatformsConductorTest::TestPlugins::Node,
+          node_ssh_test: HybridPlatformsConductorTest::TestPlugins::NodeSsh,
+          node_check_test: HybridPlatformsConductorTest::TestPlugins::NodeCheck,
+          several_tests: HybridPlatformsConductorTest::TestPlugins::SeveralChecks
+        })
+        test_tests_runner.reports = [:report]
+        yield
+      end
+    end
+
+    it 'reports correctly a global test' do
+      with_test_platforms_for_reports_test do
+        test_tests_runner.tests = [:global_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:global_tests].sort).to eq [
+          [:global_test, true]
+        ].sort
+      end
+    end
+
+    it 'reports correctly a global test that is failing' do
+      with_test_platforms_for_reports_test do
+        HybridPlatformsConductorTest::TestPlugins::Global.fail = true
+        test_tests_runner.tests = [:global_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:global_tests].sort).to eq [
+          [:global_test, true, ['Uncaught exception during test: Failing test']]
+        ].sort
+      end
+    end
+
+    it 'reports correctly a platform test' do
+      with_test_platforms_for_reports_test do
+        test_tests_runner.tests = [:platform_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:platform_tests].sort).to eq [
+          [:platform_test, true, 'platform1'],
+          [:platform_test, true, 'platform2']
+        ].sort
+      end
+    end
+
+    it 'reports correctly a platform test that is failing' do
+      with_test_platforms_for_reports_test do
+        HybridPlatformsConductorTest::TestPlugins::Platform.fail_for = ['platform1']
+        test_tests_runner.tests = [:platform_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:platform_tests].sort).to eq [
+          [:platform_test, true, 'platform1', ['Uncaught exception during test: Failing test']],
+          [:platform_test, true, 'platform2']
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node test' do
+      with_test_platforms_for_reports_test do
+        test_tests_runner.tests = [:node_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_test, true, 'node11'],
+          [:node_test, true, 'node12'],
+          [:node_test, true, 'node21'],
+          [:node_test, true, 'node22']
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node test that is failing' do
+      with_test_platforms_for_reports_test do
+        HybridPlatformsConductorTest::TestPlugins::Node.fail_for = { node_test: %w[node12 node22] }
+        test_tests_runner.tests = [:node_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_test, true, 'node11'],
+          [:node_test, true, 'node12', ['Uncaught exception during test: Failing test node_test for node12']],
+          [:node_test, true, 'node21'],
+          [:node_test, true, 'node22', ['Uncaught exception during test: Failing test node_test for node22']]
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node SSH test' do
+      with_test_platforms_for_reports_test do
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = { node_ssh_test: {
+          'node11' => { 'test_node11.sh' => proc {} },
+          'node12' => { 'test_node12.sh' => proc {} },
+          'node21' => { 'test_node21.sh' => proc {} },
+          'node22' => { 'test_node22.sh' => proc {} }
+        }}
+        expect_actions_executor_runs([proc do
+          {
+            'node11' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", ''],
+            'node12' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", ''],
+            'node21' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", ''],
+            'node22' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", '']
+          }
+        end])
+        test_tests_runner.tests = [:node_ssh_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_ssh_test, true, 'node11'],
+          [:node_ssh_test, true, 'node12'],
+          [:node_ssh_test, true, 'node21'],
+          [:node_ssh_test, true, 'node22']
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node SSH test that is failing' do
+      with_test_platforms_for_reports_test do
+        HybridPlatformsConductorTest::TestPlugins::NodeSsh.node_tests = { node_ssh_test: {
+          'node11' => { 'test_node11.sh' => proc {} },
+          'node12' => { 'test_node12.sh' => proc {} },
+          'node21' => { 'test_node21.sh' => proc {} },
+          'node22' => { 'test_node22.sh' => proc {} }
+        }}
+        expect_actions_executor_runs([proc do
+          {
+            'node11' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", ''],
+            'node12' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n1\n", 'Failing node12'],
+            'node21' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n0\n", ''],
+            'node22' => [0, "===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====\n2\n", 'Failing node22']
+          }
+        end])
+        test_tests_runner.tests = [:node_ssh_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_ssh_test, true, 'node11'],
+          [:node_ssh_test, true, 'node12', ['Command \'test_node12.sh\' returned error code 1']],
+          [:node_ssh_test, true, 'node21'],
+          [:node_ssh_test, true, 'node22', ['Command \'test_node22.sh\' returned error code 2']]
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node check test' do
+      with_test_platforms_for_reports_test do
+        expect(test_deployer).to receive(:deploy_on).with(%w[node11 node12 node21 node22]).once do
+          {
+            'node11' => [0, 'node11 check ok', ''],
+            'node12' => [0, 'node12 check ok', ''],
+            'node21' => [0, 'node21 check ok', ''],
+            'node22' => [0, 'node22 check ok', '']
+          }
+        end
+        test_tests_runner.tests = [:node_check_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_check_test, true, 'node11'],
+          [:node_check_test, true, 'node12'],
+          [:node_check_test, true, 'node21'],
+          [:node_check_test, true, 'node22']
+        ].sort
+      end
+    end
+
+    it 'reports correctly a node check test that is failing' do
+      with_test_platforms_for_reports_test do
+        expect(test_deployer).to receive(:deploy_on).with(%w[node11 node12 node21 node22]).once do
+          {
+            'node11' => [0, 'node11 check ok', ''],
+            'node12' => [1, 'node12 check ok', 'Error for node12'],
+            'node21' => [2, 'node21 check ok', 'Error for node21'],
+            'node22' => [0, 'node22 check ok', '']
+          }
+        end
+        test_tests_runner.tests = [:node_check_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:node_tests].sort).to eq [
+          [:node_check_test, true, 'node11'],
+          [:node_check_test, true, 'node12', ['Check-node returned error code 1']],
+          [:node_check_test, true, 'node21', ['Check-node returned error code 2']],
+          [:node_check_test, true, 'node22']
+        ].sort
+      end
+    end
+
+    it 'receives information about all levels being tested' do
+      with_test_platforms_for_reports_test do
+        # Mock the Actions Executor and Deployer expected calls
+        expect(test_deployer).to receive(:deploy_on).with(%w[node11 node12 node21 node22]).once do
+          expect(test_deployer.use_why_run).to eq true
+          {
+            'node11' => [0, 'node11 check ok', 'node11 stderr'],
+            'node12' => [0, 'node12 check ok', 'node12 stderr'],
+            'node21' => [0, 'node21 check ok', 'node21 stderr'],
+            'node22' => [0, 'node22 check ok', 'node22 stderr']
+          }
+        end
+        expect_actions_executor_runs([proc do |actions|
+          node_suffixes = %w[11 12 21 22]
+          expect(actions.size).to eq node_suffixes.size
+          node_suffixes.each do |node_suffix|
+            node = "node#{node_suffix}"
+            expect(actions.key?(node)).to eq true
+            expect(actions[node].size).to eq 1
+            expect(actions[node][:remote_bash]).to eq [
+              '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 =====\'',
+              "test_node#{node_suffix}.sh",
+              'echo "$?"'
+            ]
+          end
+          Hash[node_suffixes.map do |node_suffix|
+            [
+              "node#{node_suffix}",
+              [
+                0,
+                <<~EOS,
+                  ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
+                  stdout#{node_suffix}
+                  0
+                EOS
+                <<~EOS
+                  ===== TEST COMMAND EXECUTION ===== Separator generated by Hybrid Platforms Conductor test framework =====
+                  stderr#{node_suffix}
+                EOS
+              ]
+            ]
+          end]
+        end])
+        # Run everything
+        test_tests_runner.tests = [:several_tests]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        first_report = HybridPlatformsConductorTest::TestsReportPlugin.reports.first
+        expect(first_report[:global_tests].sort).to eq [
+          [:several_tests, true]
+        ].sort
+        expect(first_report[:platform_tests].sort).to eq [
+          [:several_tests, true, 'platform1'],
+          [:several_tests, true, 'platform2']
+        ].sort
+        # There are 3 node tests for each node: 1 for SSH, 1 for check-node and 1 normal
+        expect(first_report[:node_tests].sort).to eq [
+          [:several_tests, true, 'node11'],
+          [:several_tests, true, 'node12'],
+          [:several_tests, true, 'node21'],
+          [:several_tests, true, 'node22'],
+          [:several_tests, true, 'node11'],
+          [:several_tests, true, 'node12'],
+          [:several_tests, true, 'node21'],
+          [:several_tests, true, 'node22'],
+          [:several_tests, true, 'node11'],
+          [:several_tests, true, 'node12'],
+          [:several_tests, true, 'node21'],
+          [:several_tests, true, 'node22']
+        ].sort
+      end
+    end
+
+    it 'groups errors correctly by their attributes' do
+      with_test_platforms_for_reports_test do
+        test_tests_runner.tests = [:node_test, :node_test_2]
+        HybridPlatformsConductorTest::TestPlugins::Node.fail_for = {
+          node_test: %w[node12 node22],
+          node_test_2: %w[node21 node22]
+        }
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        errors_per_test = HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:errors_per_test]
+        expect(errors_per_test.size).to eq 2
+        expect(errors_per_test[:node_test].sort).to eq [
+          'Uncaught exception during test: Failing test node_test for node12',
+          'Uncaught exception during test: Failing test node_test for node22'
+        ].sort
+        expect(errors_per_test[:node_test_2].sort).to eq [
+          'Uncaught exception during test: Failing test node_test_2 for node21',
+          'Uncaught exception during test: Failing test node_test_2 for node22'
+        ].sort
+      end
+    end
+
+    it 'returns correctly nodes by nodes lists' do
+      with_test_platform(
+        {
+          nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {}, 'node4' => {}, 'node5' => {} },
+          nodes_lists: {
+            'nodes_list1' => %w[node1 node3],
+            'nodes_list2' => %w[node2 node3 node4]
+          }
+        },
+        false,
+        '
+        for_nodes(\'node1\') do
+          expect_tests_to_fail(:node_test, \'Expected failure\')
+        end
+        '
+      ) do
+        register_tests_report_plugins(test_tests_runner, report: HybridPlatformsConductorTest::TestsReportPlugin)
+        register_test_plugins(test_tests_runner, node_test: HybridPlatformsConductorTest::TestPlugins::Node)
+        HybridPlatformsConductorTest::TestPlugins::Node.fail_for = { node_test: %w[node1 node5] }
+        test_tests_runner.reports = [:report]
+        test_tests_runner.tests = [:node_test]
+        test_tests_runner.run_tests %w[node1 node2 node3 node5]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 1
+        nodes_by_nodes_list = HybridPlatformsConductorTest::TestsReportPlugin.reports.first[:nodes_by_nodes_list]
+        expect(nodes_by_nodes_list.size).to eq 4
+        expect(nodes_by_nodes_list['nodes_list1'][:nodes].sort).to eq %w[node1 node3].sort
+        expect(nodes_by_nodes_list['nodes_list1'][:tested_nodes].sort).to eq %w[node1 node3].sort
+        expect(nodes_by_nodes_list['nodes_list1'][:tested_nodes_in_error].sort).to eq %w[node1].sort
+        expect(nodes_by_nodes_list['nodes_list1'][:tested_nodes_in_error_as_expected].sort).to eq %w[node1].sort
+        expect(nodes_by_nodes_list['nodes_list2'][:nodes].sort).to eq %w[node2 node3 node4].sort
+        expect(nodes_by_nodes_list['nodes_list2'][:tested_nodes].sort).to eq %w[node2 node3].sort
+        expect(nodes_by_nodes_list['nodes_list2'][:tested_nodes_in_error].sort).to eq %w[].sort
+        expect(nodes_by_nodes_list['nodes_list2'][:tested_nodes_in_error_as_expected].sort).to eq %w[].sort
+        expect(nodes_by_nodes_list['No list'][:nodes].sort).to eq %w[node5].sort
+        expect(nodes_by_nodes_list['No list'][:tested_nodes].sort).to eq %w[node5].sort
+        expect(nodes_by_nodes_list['No list'][:tested_nodes_in_error].sort).to eq %w[node5].sort
+        expect(nodes_by_nodes_list['No list'][:tested_nodes_in_error_as_expected].sort).to eq %w[].sort
+        expect(nodes_by_nodes_list['All'][:nodes].sort).to eq %w[node1 node2 node3 node4 node5].sort
+        expect(nodes_by_nodes_list['All'][:tested_nodes].sort).to eq %w[node1 node2 node3 node5].sort
+        expect(nodes_by_nodes_list['All'][:tested_nodes_in_error].sort).to eq %w[node1 node5].sort
+        expect(nodes_by_nodes_list['All'][:tested_nodes_in_error_as_expected].sort).to eq %w[node1].sort
+      end
+    end
+
+    it 'can report on several reports' do
+      with_test_platforms_for_reports_test do
+        register_tests_report_plugins(test_tests_runner,
+          report1: HybridPlatformsConductorTest::TestsReportPlugin,
+          report2: HybridPlatformsConductorTest::TestsReportPlugin
+        )
+        test_tests_runner.reports = %i[report1 report2]
+        test_tests_runner.tests = [:global_test]
+        test_tests_runner.run_tests [{ all: true }]
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports.size).to eq 2
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports[0][:global_tests].sort).to eq [
+          [:global_test, true]
+        ].sort
+        expect(HybridPlatformsConductorTest::TestsReportPlugin.reports[1][:global_tests].sort).to eq [
+          [:global_test, true]
+        ].sort
+      end
+    end
+
+  end
+
+end