hybrid_platforms_conductor 32.3.6

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

@@ -0,0 +1,194 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  it 'executes all tests when no test is selected' do
+    with_test_platform do
+      register_test_plugins(test_tests_runner,
+        global_test: HybridPlatformsConductorTest::TestPlugins::Global,
+        global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
+      )
+      expect(test_tests_runner.run_tests([])).to eq 0
+      expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 2
+    end
+  end
+
+  it 'executes all tests when all tests are selected' do
+    with_test_platform do
+      register_test_plugins(test_tests_runner,
+        global_test: HybridPlatformsConductorTest::TestPlugins::Global,
+        global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
+      )
+      test_tests_runner.tests = [:all]
+      expect(test_tests_runner.run_tests([])).to eq 0
+      expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 2
+    end
+  end
+
+  it 'returns 1 when tests are failing' 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
+      expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 0
+    end
+  end
+
+  it 'returns 0 when tests are failing as expected' do
+    with_test_platform({}, false, '
+      expect_tests_to_fail(:platform_test, \'Expected failure\')
+    ') 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
+      expect(HybridPlatformsConductorTest::TestPlugins::Platform.runs).to eq []
+    end
+  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
+      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
+      expect(HybridPlatformsConductorTest::TestPlugins::Node.runs.sort).to eq [[:node_test, 'node1'], [:node_test, 'node3']].sort
+    end
+  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
+      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']]
+    end
+  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
+      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']]
+    end
+  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\')
+        end
+      '
+    ) 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'
+    end
+  end
+
+  it 'fails when we ask for an unknown test' 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')
+    end
+  end
+
+  it 'executes different tests levels if 1 plugin defines them' do
+    with_test_platforms(
+      '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
+      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::TestPlugins::SeveralChecks.runs.sort).to eq [
+        [:several_tests, '', '', 'Global test'],
+        [:several_tests, 'platform1', '', 'Platform test'],
+        [:several_tests, 'platform2', '', 'Platform test'],
+        [:several_tests, 'node11', 'Node test'],
+        [:several_tests, 'node12', 'Node test'],
+        [:several_tests, 'node21', 'Node test'],
+        [:several_tests, 'node22', 'Node test'],
+        [:several_tests, 'node11', 'Node SSH test: stdout11 - stderr11'],
+        [:several_tests, 'node12', 'Node SSH test: stdout12 - stderr12'],
+        [:several_tests, 'node21', 'Node SSH test: stdout21 - stderr21'],
+        [:several_tests, 'node22', 'Node SSH test: stdout22 - stderr22'],
+        [:several_tests, 'node11', 'Node check-node test: node11 check ok'],
+        [:several_tests, 'node12', 'Node check-node test: node12 check ok'],
+        [:several_tests, 'node21', 'Node check-node test: node21 check ok'],
+        [:several_tests, 'node22', 'Node check-node test: node22 check ok']
+      ].sort
+    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
+      test_tests_runner.tests = [:specific_platform_handler_test]
+      expect(test_tests_runner.run_tests([])).to eq 0
+      expect(SpecificPlatformHandlerTest.run).to eq true
+    end
+  end
+
+end

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

@@ -0,0 +1,37 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking global tests execution' do
+
+    # Prepare the test platform with test plugins
+    #
+    # Parameters::
+    # * *platforms_info* (Hash): The platofrms info [default: {}]
+    def with_test_platform_for_global_tests(platforms_info: {})
+      with_test_platform(platforms_info) do
+        register_test_plugins(test_tests_runner,
+          global_test: HybridPlatformsConductorTest::TestPlugins::Global,
+          global_test_2: HybridPlatformsConductorTest::TestPlugins::Global
+        )
+        yield
+      end
+    end
+
+    it 'executes 1 global test only once even if there are several nodes' do
+      with_test_platform_for_global_tests(platforms_info: { nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {} } }) do
+        test_tests_runner.tests = [:global_test]
+        expect(test_tests_runner.run_tests(%w[node1 node2 node3])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 1
+      end
+    end
+
+    it 'executes several global tests' do
+      with_test_platform_for_global_tests do
+        test_tests_runner.tests = [:global_test, :global_test_2]
+        expect(test_tests_runner.run_tests([])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Global.nbr_runs).to eq 2
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,194 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking node tests on check-node results' do
+
+    # Prepare the test platform with test plugins
+    #
+    # Parameters::
+    # * 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 }
+      ) do
+        register_test_plugins(test_tests_runner,
+          node_check_test: HybridPlatformsConductorTest::TestPlugins::NodeCheck,
+          node_check_test_2: HybridPlatformsConductorTest::TestPlugins::NodeCheck
+        )
+        yield
+      end
+    end
+
+    it 'executes check node tests once per node' do
+      with_test_platform_for_node_check_tests do
+        test_tests_runner.tests = [:node_check_test]
+        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(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok', 'node11 stderr', 0],
+          [:node_check_test, 'node12', 'node12 check ok', 'node12 stderr', 0],
+          [:node_check_test, 'node21', 'node21 check ok', 'node21 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+    it 'executes check node tests only on specified nodes' do
+      with_test_platform_for_node_check_tests do
+        test_tests_runner.tests = [:node_check_test]
+        expect(test_deployer).to receive(:deploy_on).with(%w[node12 node22]).once do
+          expect(test_deployer.use_why_run).to eq true
+          {
+            'node12' => [0, 'node12 check ok', 'node12 stderr'],
+            'node22' => [0, 'node22 check ok', 'node22 stderr']
+          }
+        end
+        expect(test_tests_runner.run_tests(%w[node12 node22])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node12', 'node12 check ok', 'node12 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+    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]
+        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(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok', 'node11 stderr', 0],
+          [:node_check_test, 'node12', 'node12 check ok', 'node12 stderr', 0],
+          [:node_check_test, 'node21', 'node21 check ok', 'node21 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0],
+          [:node_check_test_2, 'node11', 'node11 check ok', 'node11 stderr', 0],
+          [:node_check_test_2, 'node12', 'node12 check ok', 'node12 stderr', 0],
+          [:node_check_test_2, 'node21', 'node21 check ok', 'node21 stderr', 0],
+          [:node_check_test_2, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+    it 'fails when a check node tests returns an error for a node' do
+      with_test_platform_for_node_check_tests do
+        test_tests_runner.tests = [:node_check_test]
+        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' => [1, 'node12 check ok', 'node12 stderr'],
+            'node21' => [0, 'node21 check ok', 'node21 stderr'],
+            'node22' => [0, 'node22 check ok', 'node22 stderr']
+          }
+        end
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 1
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok', 'node11 stderr', 0],
+          [:node_check_test, 'node12', 'node12 check ok', 'node12 stderr', 1],
+          [:node_check_test, 'node21', 'node21 check ok', 'node21 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+    it 'fails when a check node tests raises an error' do
+      with_test_platform_for_node_check_tests do
+        test_tests_runner.tests = [:node_check_test]
+        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' => [1, 'node12 check ok', 'node12 stderr'],
+            'node21' => [0, 'node21 check ok', 'node21 stderr'],
+            'node22' => [0, 'node22 check ok', 'node22 stderr']
+          }
+        end
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.fail_for = ['node12']
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 1
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok', 'node11 stderr', 0],
+          [:node_check_test, 'node21', 'node21 check ok', 'node21 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+    it 'reuses run_logs logs instead of running check-node when we ask for it' do
+      with_test_platform_for_node_check_tests do
+        run_logs_dir = "#{ENV['hpc_platforms']}/run_logs"
+        FileUtils.mkdir_p run_logs_dir
+        File.write("#{run_logs_dir}/node11.stdout", 'node11 check ok from logs')
+        File.write("#{run_logs_dir}/node12.stdout", 'node12 check ok from logs')
+        File.write("#{run_logs_dir}/node21.stdout", 'node21 check ok from logs')
+        File.write("#{run_logs_dir}/node22.stdout", 'node22 check ok from logs')
+        test_tests_runner.tests = [:node_check_test]
+        expect(test_deployer).not_to receive(:deploy_on)
+        test_tests_runner.skip_run = true
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok from logs', '', 0],
+          [:node_check_test, 'node12', 'node12 check ok from logs', '', 0],
+          [:node_check_test, 'node21', 'node21 check ok from logs', '', 0],
+          [:node_check_test, 'node22', 'node22 check ok from logs', '', 0]
+        ].sort
+      end
+    end
+
+    it 'fails when some run_logs are missing' do
+      with_test_platform_for_node_check_tests do
+        run_logs_dir = "#{ENV['hpc_platforms']}/run_logs"
+        FileUtils.mkdir_p run_logs_dir
+        File.write("#{run_logs_dir}/node11.stdout", 'node11 check ok from logs')
+        File.write("#{run_logs_dir}/node12.stdout", 'node12 check ok from logs')
+        FileUtils.rm_f "#{run_logs_dir}/node21.stdout"
+        File.write("#{run_logs_dir}/node22.stdout", 'node22 check ok from logs')
+        test_tests_runner.tests = [:node_check_test]
+        expect(test_deployer).not_to receive(:deploy_on)
+        test_tests_runner.skip_run = true
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 1
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node11', 'node11 check ok from logs', '', 0],
+          [:node_check_test, 'node12', 'node12 check ok from logs', '', 0],
+          [:node_check_test, 'node22', 'node22 check ok from logs', '', 0]
+        ].sort
+      end
+    end
+
+    it 'executes check node tests only on valid nodes' do
+      with_test_platform_for_node_check_tests do
+        HybridPlatformsConductorTest::TestPlugins::NodeCheck.only_on_nodes = %w[node12 node22]
+        test_tests_runner.tests = [:node_check_test]
+        expect(test_deployer).to receive(:deploy_on).with(%w[node12 node22]).once do
+          expect(test_deployer.use_why_run).to eq true
+          {
+            'node12' => [0, 'node12 check ok', 'node12 stderr'],
+            'node22' => [0, 'node22 check ok', 'node22 stderr']
+          }
+        end
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::NodeCheck.runs.sort).to eq [
+          [:node_check_test, 'node12', 'node12 check ok', 'node12 stderr', 0],
+          [:node_check_test, 'node22', 'node22 check ok', 'node22 stderr', 0]
+        ].sort
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,137 @@
+describe HybridPlatformsConductor::TestsRunner do
+
+  context 'checking 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_tests
+      with_test_platforms(
+        'platform1' => { nodes: { 'node11' => {}, 'node12' => {}, 'node13' => {} } },
+        'platform2' => { nodes: { 'node21' => {}, 'node22' => {}, 'node23' => {} }, platform_type: :test2 }
+      ) do
+        register_test_plugins(test_tests_runner,
+          node_test: HybridPlatformsConductorTest::TestPlugins::Node,
+          node_test_2: HybridPlatformsConductorTest::TestPlugins::Node
+        )
+        yield
+      end
+    end
+
+    it 'executes node tests once per node' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [:node_test]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Node.runs.sort).to eq [
+          [:node_test, 'node11'],
+          [:node_test, 'node12'],
+          [:node_test, 'node13'],
+          [:node_test, 'node21'],
+          [:node_test, 'node22'],
+          [:node_test, 'node23']
+        ].sort
+      end
+    end
+
+    it 'executes node tests only on selected nodes' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [:node_test]
+        expect(test_tests_runner.run_tests(%w[node12 node22])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Node.runs.sort).to eq [
+          [:node_test, 'node12'],
+          [:node_test, 'node22']
+        ].sort
+      end
+    end
+
+    it 'executes several node tests' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [: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'],
+          [:node_test, 'node12'],
+          [:node_test, 'node13'],
+          [:node_test, 'node21'],
+          [:node_test, 'node22'],
+          [:node_test, 'node23'],
+          [:node_test_2, 'node11'],
+          [:node_test_2, 'node12'],
+          [:node_test_2, 'node13'],
+          [:node_test_2, 'node21'],
+          [:node_test_2, 'node22'],
+          [:node_test_2, 'node23']
+        ].sort
+      end
+    end
+
+    it 'executes node tests only on valid nodes' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [:node_test]
+        HybridPlatformsConductorTest::TestPlugins::Node.only_on_nodes = %w[node12 node22]
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Node.runs.sort).to eq [
+          [:node_test, 'node12'],
+          [:node_test, 'node22']
+        ].sort
+      end
+    end
+
+    it 'executes node tests in parallel' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [:node_test]
+        test_tests_runner.max_threads_nodes = 6
+        HybridPlatformsConductorTest::TestPlugins::Node.sleeps = { node_test: {
+          'node11' => 3.0,
+          'node12' => 0.5,
+          'node13' => 1.5,
+          'node21' => 2.0,
+          'node22' => 1.0,
+          'node23' => 2.5
+        } }
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Node.runs).to eq [
+          [:node_test, 'node12'],
+          [:node_test, 'node22'],
+          [:node_test, 'node13'],
+          [:node_test, 'node21'],
+          [:node_test, 'node23'],
+          [:node_test, 'node11']
+        ]
+      end
+    end
+
+    it 'executes node tests not in parallel with a limiting number of threads' do
+      with_test_platform_for_node_tests do
+        test_tests_runner.tests = [:node_test]
+        test_tests_runner.max_threads_nodes = 3
+        HybridPlatformsConductorTest::TestPlugins::Node.sleeps = { node_test: {
+          'node11' => 1.4,
+          'node12' => 0.2,
+          'node13' => 0.6,
+          'node21' => 0.8,
+          'node22' => 0.6,
+          'node23' => 1
+        } }
+        # Here is the sequence:
+        # Thread 1: +-node11 1.4--------------------------------------------+
+        # Thread 2: +-node12 0.2-+-node21 0.8--------------+-node23 1.0-----|---+
+        # Thread 3: +-node13 0.6-|------------+-node22 0.6-|------------+   |   |
+        #           |            |            |            |            |   |   |
+        # Time    : 0            0.2          0.6          1.0          1.2 1.4 2.0
+        expect(test_tests_runner.run_tests([{ all: true }])).to eq 0
+        expect(HybridPlatformsConductorTest::TestPlugins::Node.runs).to eq [
+          [:node_test, 'node12'],
+          [:node_test, 'node13'],
+          [:node_test, 'node21'],
+          [:node_test, 'node22'],
+          [:node_test, 'node11'],
+          [:node_test, 'node23']
+        ]
+      end
+    end
+
+  end
+
+end