hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/executables/options/nodes_handler_spec.rb

@@ -0,0 +1,111 @@
+describe 'executables\' Nodes Handler options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_nodes_handler_options
+    with_test_platforms(
+      {
+        'platform_1' => {
+          nodes: {
+            'node11' => {
+              meta: { host_ip: '192.168.42.11' },
+              services: ['service1']
+            },
+            'node12' => {
+              meta: {
+                host_ip: '192.168.42.12',
+                description: 'Node12 description'
+              },
+              services: ['service1']
+            },
+            'node13' => {
+              meta: { host_ip: '192.168.42.13' },
+              services: ['service2']
+            },
+            'node14' => {
+              meta: { private_ips: ['192.168.42.14', '172.16.42.14'] }
+            },
+            'node15' => {
+              meta: {
+                hostname: 'my_host15.my_domain'
+              }
+            },
+            'node16' => {
+              meta: {
+                host_ip: '192.168.42.16',
+                hostname: 'my_host16.my_domain'
+              }
+            }
+          },
+          nodes_lists: { 'my_list' => ['node11', 'node13'] }
+        },
+        'platform_2' => {
+          nodes: {
+            'node21' => {
+              meta: { host_ip: '192.168.42.21' },
+              services: ['service2', 'service3']
+            },
+            'node22' => {
+              meta: { host_ip: '192.168.42.22' },
+              services: ['service1']
+            }
+          }
+        }
+      }
+    ) do |repository|
+      yield repository
+    end
+  end
+
+  it 'displays info about nodes' do
+    with_test_platform_for_nodes_handler_options do
+      with_cmd_runner_mocked [
+        ['getent hosts my_host15.my_domain', proc { [0, '192.168.42.15 my_host16.my_domain', ''] }],
+        ['getent hosts my_host16.my_domain', proc { [0, '192.168.42.16 my_host16.my_domain', ''] }]
+      ] do
+        exit_code, stdout, stderr = run 'run', '--show-nodes'
+        expect(exit_code).to eq 0
+        expect(stdout).to eq <<~EOS
+          * Known platforms:
+          platform_1 - Type: test - Location: /tmp/hpc_test/platform_1
+          platform_2 - Type: test - Location: /tmp/hpc_test/platform_2
+
+          * Known nodes lists:
+          my_list
+
+          * Known services:
+          service1
+          service2
+          service3
+
+          * Known nodes:
+          node11
+          node12
+          node13
+          node14
+          node15
+          node16
+          node21
+          node22
+
+          * Known nodes with description:
+          node11 (192.168.42.11) - service1 - 
+          node12 (192.168.42.12) - service1 - Node12 description
+          node13 (192.168.42.13) - service2 - 
+          node14 (192.168.42.14) -  - 
+          node15 (my_host15.my_domain) -  - 
+          node16 (my_host16.my_domain) -  - 
+          node21 (192.168.42.21) - service2, service3 - 
+          node22 (192.168.42.22) - service1 - 
+
+        EOS
+        expect(stderr).to eq ''
+      end
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/nodes_selectors_spec.rb

@@ -0,0 +1,71 @@
+describe 'executables\' nodes selection options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_nodes_selector_options
+    with_test_platforms(
+      {
+        'platform_1' => {
+          nodes: {
+            'node11' => { services: ['service1'] },
+            'node12' => { services: ['service3', 'service1'] },
+            'node13' => { services: ['service2'] }
+          },
+          nodes_lists: { 'my_list' => ['node11', 'node13'] }
+        },
+        'platform_2' => {
+          nodes: {
+            'node21' => { services: ['service2'] },
+            'node22' => { services: ['service1'] }
+          }
+        }
+      }
+    ) do |repository|
+      yield repository
+    end
+  end
+
+  # Enumerate all command-line selectors to test, and the corresponding nodes list
+  {
+    ['--all-nodes'] => [{ all: true }],
+    ['--node', 'node11'] => ['node11'],
+    ['--node', '/node1.+/'] => [/node1.+/],
+    ['--nodes-list', 'my_list'] => [{ list: 'my_list' }],
+    ['--nodes-platform', 'platform_2'] => [{ platform: 'platform_2' }],
+    ['--nodes-service', 'service1'] => [{ service: 'service1' }],
+    ['--node', 'node11', '--node', 'node12'] => %w[node11 node12],
+    ['--nodes-service', 'service1', '--nodes-platform', 'platform_2'] => [{ service: 'service1' }, { platform: 'platform_2' }],
+    ['--nodes-git-impact', 'platform_2'] => [{ git_diff: { platform: 'platform_2' } }],
+    ['--nodes-git-impact', 'platform_2:from_commit'] => [
+      { git_diff: { platform: 'platform_2', from_commit: 'from_commit' } }
+    ],
+    ['--nodes-git-impact', 'platform_2:from_commit:to_commit'] => [
+      { git_diff: { platform: 'platform_2', from_commit: 'from_commit', to_commit: 'to_commit' } }
+    ],
+    ['--nodes-git-impact', 'platform_2:from_commit:to_commit:min'] => [
+      { git_diff: { platform: 'platform_2', from_commit: 'from_commit', to_commit: 'to_commit', smallest_set: true } }
+    ],
+    ['--nodes-git-impact', 'platform_2::to_commit:min'] => [
+      { git_diff: { platform: 'platform_2', to_commit: 'to_commit', smallest_set: true } }
+    ],
+    ['--nodes-git-impact', 'platform_2:::min'] => [
+      { git_diff: { platform: 'platform_2', smallest_set: true } }
+    ]
+  }.each do |args, expected_nodes|
+
+    it "resolves '#{args.join(' ')}' into #{expected_nodes.join(', ')}" do
+      with_test_platform_for_nodes_selector_options do
+        expect(test_deployer).to receive(:deploy_on).with(expected_nodes) { {} }
+        exit_code, stdout, stderr = run 'deploy', *args
+        expect(exit_code).to eq 0
+        expect(stderr).to eq ''
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/reports_handler_spec.rb

@@ -0,0 +1,54 @@
+describe 'executables\' Reports Handler options' do
+
+  # Setup a platform for tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_reports_handler_options
+    with_test_platform do |repository|
+      register_report_plugins(test_reports_handler, report_format: HybridPlatformsConductorTest::ReportPlugin)
+      yield repository
+    end
+  end
+
+  it 'uses a given format' do
+    with_test_platform_for_reports_handler_options do
+      expect(test_reports_handler).to receive(:produce_report_for).with([{ all: true }]) do
+        expect(test_reports_handler.format).to eq :report_format
+        {}
+      end
+      exit_code, stdout, stderr = run 'report', '--format', 'report_format'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails to use an unknown format' do
+    with_test_platform_for_reports_handler_options do
+      expect { run 'report', '--format', 'unknown_format' }.to raise_error(RuntimeError, 'Unknown format: unknown_format')
+    end
+  end
+
+  it 'uses a given locale' do
+    with_test_platform_for_reports_handler_options do
+      expect(test_reports_handler).to receive(:produce_report_for).with([{ all: true }]) do
+        expect(test_reports_handler.locale).to eq :fr
+        {}
+      end
+      exit_code, stdout, stderr = run 'report', '--format', 'report_format', '--locale', 'fr'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails to use an unknown locale' do
+    with_test_platform_for_reports_handler_options do
+      expect { run 'report', '--format', 'report_format', '--locale', 'unknown_locale' }.to raise_error(RuntimeError, 'Unknown locale for format report_format: unknown_locale')
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/options/tests_runner_spec.rb

@@ -0,0 +1,139 @@
+describe 'executables\' Tests Runner options' do
+
+  it 'specifies a given test to execute' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.tests.sort).to eq %i[my_test]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--test', 'my_test'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies several tests to execute' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.tests.sort).to eq %i[my_test1 my_test2]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--test', 'my_test1', '--test', 'my_test2'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies a tests file to execute' do
+    with_test_platform do |repository|
+      tests_file = "#{repository}/my_tests.txt"
+      File.write(tests_file, "my_test1\n# Comment to ignore\nmy_test2\n")
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.tests.sort).to eq %i[my_test1 my_test2]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--tests-list', tests_file
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies a mix of tests files and test names to execute' do
+    with_test_platform do |repository|
+      tests_file1 = "#{repository}/my_tests1.txt"
+      File.write(tests_file1, "my_test1\n# Comment to ignore\nmy_test2\n")
+      tests_file2 = "#{repository}/my_tests2.txt"
+      File.write(tests_file2, "my_test4\n# Comment to ignore\nmy_test5\n")
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.tests.sort).to eq %i[my_test1 my_test2 my_test3 my_test4 my_test5 my_test6]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--tests-list', tests_file1, '--test', 'my_test3', '--tests-list', tests_file2, '--test', 'my_test6'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'uses current run_logs instead of executing new check-nodes' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.skip_run).to eq true
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--test', 'my_test', '--skip-run'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'reports into a given format' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.reports).to eq %i[my_report]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--report', 'my_report'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'reports into several formats' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.reports.sort).to eq %i[my_report1 my_report2].sort
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--report', 'my_report1', '--report', 'my_report2'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies the number of max threads for connections to nodes' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.max_threads_connection_on_nodes).to eq 43
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--max-threads-connections', '43'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies the number of max threads for node tests' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.max_threads_nodes).to eq 43
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--max-threads-nodes', '43'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'specifies the number of max threads for platform tests' do
+    with_test_platform do
+      expect(test_tests_runner).to receive(:run_tests).with([]) do
+        expect(test_tests_runner.max_threads_platforms).to eq 43
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--max-threads-platforms', '43'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/report_spec.rb

@@ -0,0 +1,60 @@
+describe 'report executable' do
+
+  it 'reports by default on all nodes' do
+    with_test_platform(nodes: { 'node1' => { services: ['node1_service'] }, 'node2' => { services: ['node2_service'] } }) do
+      exit_code, stdout, stderr = run 'report'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+        | Node  | Platform | Host name | IP | Physical? | OS | Description | Services      |
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+        | node1 | platform |           |    | No        |    |             | node1_service |
+        | node2 | platform |           |    | No        |    |             | node2_service |
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+      EOS
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'reports on given nodes only' do
+    with_test_platform(nodes: { 'node1' => { services: ['node1_service'] }, 'node2' => { services: ['node2_service'] } }) do
+      exit_code, stdout, stderr = run 'report', '--node', 'node2'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq <<~EOS
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+        | Node  | Platform | Host name | IP | Physical? | OS | Description | Services      |
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+        | node2 | platform |           |    | No        |    |             | node2_service |
+        +-------+----------+-----------+----+-----------+----+-------------+---------------+
+      EOS
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'reports info from metadata' do
+    with_test_platform(nodes: { 'node' => {
+       meta: {
+        hostname: 'node.domain.com',
+        image: 'debian_10',
+        description: 'A great server'
+      },
+      services: ['node_service1', 'node_service2']
+    } }) do
+      with_cmd_runner_mocked [
+        ['getent hosts node.domain.com', proc { [0, '192.168.0.1 node.domain.com', ''] }]
+      ] do
+        exit_code, stdout, stderr = run 'report', '--node', 'node'
+        expect(exit_code).to eq 0
+        expect(stdout).to eq <<~EOS
+          +------+----------+-----------------+-------------+-----------+-----------+----------------+------------------------------+
+          | Node | Platform | Host name       | IP          | Physical? | OS        | Description    | Services                     |
+          +------+----------+-----------------+-------------+-----------+-----------+----------------+------------------------------+
+          | node | platform | node.domain.com | 192.168.0.1 | No        | debian_10 | A great server | node_service1, node_service2 |
+          +------+----------+-----------------+-------------+-----------+-----------+----------------+------------------------------+
+        EOS
+        expect(stderr).to eq ''
+      end
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/run_spec.rb

@@ -0,0 +1,173 @@
+describe 'run executable' do
+
+  # Setup a platform for run tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_run
+    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  it 'executes a single command on a node' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello'] }])
+        test_actions_executor.stdout_device << "Hello\n"
+        { 'node1' => [0, "Hello\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes a command file on a node' do
+    with_test_platform_for_run do |repository|
+      commands_file = "#{repository}/commands.txt"
+      File.write(commands_file, "echo Hello1\necho Hello2\n")
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ remote_bash: [{ file: commands_file }] }])
+        test_actions_executor.stdout_device << "Hello1\nHello2\n"
+        { 'node1' => [0, "Hello1\nHello2\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command-file', commands_file
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello1/
+      expect(stdout).to match /Hello2/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes a single command on a node with timeout' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(timeout).to eq 5
+        expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello'] }])
+        test_actions_executor.stdout_device << "Hello\n"
+        { 'node1' => [0, "Hello\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello', '--timeout', '5'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes a single command on a node and captures stderr correctly' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello 2>&1'] }])
+        test_actions_executor.stderr_device << "Hello\n"
+        { 'node1' => [0, '', "Hello\n"] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello 2>&1'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to match /Hello/
+    end
+  end
+
+  it 'executes a single command on several nodes' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(concurrent).to eq false
+        expect(actions).to eq(%w[node1 node2] => [{ remote_bash: ['echo Hello'] }])
+        test_actions_executor.stdout_device << "Hello\nHello\n"
+        { 'node1' => [0, "Hello\nHello\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--node', 'node2', '--command', 'echo Hello'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes several commands' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello1', 'echo Hello2'] }])
+        test_actions_executor.stdout_device << "Hello1\nHello2\n"
+        { 'node1' => [0, "Hello1\nHello2\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello1', '--command', 'echo Hello2'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello1/
+      expect(stdout).to match /Hello2/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes several commands and commands files ordered by arguments' do
+    with_test_platform_for_run do |repository|
+      commands_file_1 = "#{repository}/commands1.txt"
+      File.write(commands_file_1, "echo Hello1\necho Hello2\n")
+      commands_file_2 = "#{repository}/commands2.txt"
+      File.write(commands_file_1, "echo Hello4\necho Hello5\n")
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ remote_bash: [
+          { file: commands_file_1 },
+          'echo Hello3',
+          { file: commands_file_2 },
+          'echo Hello6'
+        ] }])
+        test_actions_executor.stdout_device << "Hello1\nHello2\nHello3\nHello4\nHello5\nHello6\n"
+        { 'node1' => [0, "Hello1\nHello2\nHello3\nHello4\nHello5\nHello6\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--commands-file', commands_file_1, '--command', 'echo Hello3', '--commands-file', commands_file_2, '--command', 'echo Hello6'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello1/
+      expect(stdout).to match /Hello2/
+      expect(stdout).to match /Hello3/
+      expect(stdout).to match /Hello4/
+      expect(stdout).to match /Hello5/
+      expect(stdout).to match /Hello6/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes in parallel' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(concurrent).to eq true
+        expect(actions).to eq(%w[node1 node2] => [{ remote_bash: ['echo Hello'] }])
+        test_actions_executor.stdout_device << "Hello\nHello\n"
+        { 'node1' => [0, "Hello\nHello\n", ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--node', 'node2', '--command', 'echo Hello', '--parallel'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /Hello/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'executes an interactive session on a node' do
+    with_test_platform_for_run do
+      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+        expect(actions).to eq(['node1'] => [{ interactive: true }])
+        { 'node1' => [0, '', ''] }
+      end])
+      exit_code, stdout, stderr = run 'run', '--node', 'node1', '--interactive'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails when neither commands nor interactive session are present' do
+    with_test_platform_for_run do
+      expect { run 'run', '--node', 'node1' }.to raise_error(RuntimeError, '--interactive or --command options have to be present')
+    end
+  end
+
+  it 'fails when no node is specified' do
+    with_test_platform_for_run do
+      expect { run 'run', '--command', 'echo Hello' }.to raise_error(RuntimeError, 'No node selected. Please use --node option to set at least one.')
+    end
+  end
+
+end