hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/api/actions_executor/timeout_spec.rb

@@ -0,0 +1,101 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking timeouts' do
+
+    # Get a test platform to test timeouts
+    #
+    # Parameters::
+    # * Proc: Code called with platform setup
+    def with_test_platform_for_timeouts_tests
+      with_test_platform_for_executor(nodes: { 'node' => {} }) do
+        yield
+      end
+    end
+
+    it 'executes an action without timeout' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          'node' => { test_action: { code: proc do |stdout, _stderr, action|
+            expect(action.timeout).to eq nil
+            stdout << 'Hello'
+          end } }
+        )['node']).to eq [0, 'Hello', '']
+      end
+    end
+
+    it 'executes an action with timeout' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          { 'node' => { test_action: { code: proc do |stdout, _stderr, action|
+            expect(action.timeout).to eq 1
+            stdout << 'Hello'
+          end } } },
+          timeout: 1
+        )['node']).to eq [0, 'Hello', '']
+      end
+    end
+
+    it 'executes an action that fails because of timeout' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          { 'node' => { test_action: { code: proc do |_stdout, _stderr, action|
+            raise HybridPlatformsConductor::CmdRunner::TimeoutError
+          end } } },
+          timeout: 1
+        )['node']).to eq [:timeout, '', '']
+      end
+    end
+
+    it 'executes an action that fails because of timeout and outputs data before' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          { 'node' => { test_action: { code: proc do |stdout, _stderr, action|
+            stdout << 'Hello'
+            raise HybridPlatformsConductor::CmdRunner::TimeoutError
+          end } } },
+          timeout: 1
+        )['node']).to eq [:timeout, 'Hello', '']
+      end
+    end
+
+    it 'executes several actions with latter ones failing because of timeout' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          { 'node' => [
+            { test_action: { code: proc do |stdout|
+              sleep 1
+              stdout << 'Hello'
+            end } },
+            { test_action: { code: proc do |stdout, _stderr, action|
+              raise HybridPlatformsConductor::CmdRunner::TimeoutError
+            end } }
+          ] },
+          timeout: 5
+        )['node']).to eq [:timeout, 'Hello', '']
+      end
+    end
+
+    it 'executes several actions with a decreasing timeout' do
+      with_test_platform_for_timeouts_tests do
+        expect(test_actions_executor.execute_actions(
+          { 'node' => [
+            { test_action: { code: proc do |stdout, _stderr, action|
+              expect(action.timeout).to eq 5
+              sleep 1
+            end } },
+            { test_action: { code: proc do |stdout, _stderr, action|
+              expect(action.timeout).to be_between(3.8, 4)
+              sleep 1
+            end } },
+            { test_action: { code: proc do |stdout, _stderr, action|
+              expect(action.timeout).to be_between(2.8, 3)
+            end } }
+          ] },
+          timeout: 5
+        )['node']).to eq [0, '', '']
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/cmd_runner_spec.rb

@@ -0,0 +1,165 @@
+describe HybridPlatformsConductor::CmdRunner do
+
+  it 'runs a simple bash command' do
+    with_repository do |repository|
+      test_cmd_runner.run_cmd "echo TestContent >#{repository}/test_file"
+      expect(File.read("#{repository}/test_file")).to eq "TestContent\n"
+    end
+  end
+
+  it 'runs a simple bash command and returns exit code, stdout and stderr correctly' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; echo TestStdout").to eq [0, "TestStdout\n", "TestStderr\n"]
+    end
+  end
+
+  it 'runs a simple bash command and logs stdout and stderr to a file' do
+    with_repository do |repository|
+      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_to_file: "#{repository}/test_file"
+      expect(File.read("#{repository}/test_file")).to eq "TestStderr\nTestStdout\n"
+    end
+  end
+
+  it 'runs a simple bash command and logs stdout and stderr to an existing file' do
+    with_repository do |repository|
+      File.write("#{repository}/test_file", "Before\n")
+      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_to_file: "#{repository}/test_file"
+      expect(File.read("#{repository}/test_file")).to eq "Before\nTestStderr\nTestStdout\n"
+    end
+  end
+
+  it 'runs a simple bash command and logs stdout and stderr to IO objects' do
+    with_repository do |repository|
+      stdout = ''
+      stderr = ''
+      test_cmd_runner.run_cmd "echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout", log_stdout_to_io: stdout, log_stderr_to_io: stderr
+      expect(stdout).to eq "TestStdout\n"
+      expect(stderr).to eq "TestStderr\n"
+    end
+  end
+
+  it 'fails when the command does not exit 0' do
+    with_repository do |repository|
+      expect { test_cmd_runner.run_cmd 'exit 1' }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 0).')
+    end
+  end
+
+  it 'fails when the command does not exit with the expected code' do
+    with_repository do |repository|
+      expect { test_cmd_runner.run_cmd 'exit 1', expected_code: 2 }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 2).')
+    end
+  end
+
+  it 'fails when the command does not exit with one of the expected codes' do
+    with_repository do |repository|
+      expect { test_cmd_runner.run_cmd 'exit 1', expected_code: [0, 2, 3] }.to raise_error(HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command \'exit 1\' returned error code 1 (expected 0, 2, 3).')
+    end
+  end
+
+  it 'does not fail when the command exits with the expected code' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'exit 2', expected_code: 2).to eq [2, '', '']
+    end
+  end
+
+  it 'does not fail when the command exits with one of the expected codes' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'exit 2', expected_code: [0, 2, 3]).to eq [2, '', '']
+    end
+  end
+
+  it 'does not fail when the command does not exit 0 and we specify no exception' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'exit 1', no_exception: true).to eq [1, '', '']
+    end
+  end
+
+  it 'does not fail when the command can\'t be run and we specify no exception' do
+    with_repository do |repository|
+      exit_status, stdout, stderr = test_cmd_runner.run_cmd 'unknown_command', no_exception: true
+      expect(exit_status).to eq :command_error
+      expect(stdout).to eq ''
+      expect(stderr).to match /^No such file or directory - unknown_command.*/
+    end
+  end
+
+  it 'does not fail when the command is expected to not be run' do
+    with_repository do |repository|
+      exit_status, stdout, stderr = test_cmd_runner.run_cmd 'unknown_command', expected_code: :command_error
+      expect(exit_status).to eq :command_error
+      expect(stdout).to eq ''
+      expect(stderr).to match /^No such file or directory - unknown_command.*/
+    end
+  end
+
+  it 'fails when the command times out' do
+    with_repository do |repository|
+      expect { test_cmd_runner.run_cmd 'sleep 5', timeout: 1 }.to raise_error(HybridPlatformsConductor::CmdRunner::TimeoutError, 'Command \'sleep 5\' returned error code timeout (expected 0).')
+    end
+  end
+
+  it 'returns the timeout error when the command times out and we specify no exception' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'sleep 5', timeout: 1, no_exception: true).to eq [:timeout, '', 'Timeout of 1 triggered']
+    end
+  end
+
+  it 'returns the timeout error when the command is expected to time out' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'sleep 5', timeout: 1, expected_code: :timeout).to eq [:timeout, '', 'Timeout of 1 triggered']
+    end
+  end
+
+  it 'returns the timeout error with previously output stdout and stderr when the command times out and we specify no exception' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, no_exception: true).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
+    end
+  end
+
+  it 'returns the timeout error with previously output stdout and stderr when the command times out as expected' do
+    with_repository do |repository|
+      expect(test_cmd_runner.run_cmd 'echo TestStderr 1>&2 ; sleep 1 ; echo TestStdout ; sleep 5 ; echo NeverDisplayed', timeout: 2, expected_code: :timeout).to eq [:timeout, "TestStdout\n", "TestStderr\n\nTimeout of 2 triggered"]
+    end
+  end
+
+  it 'displays commands instead of unning them with dry-run' do
+    with_repository do |repository|
+      cmd_runner = test_cmd_runner
+      cmd_runner.dry_run = true
+      expect(cmd_runner.run_cmd "echo TestContent >#{repository}/test_file").to eq [0, '', '']
+      expect(File.exist?("#{repository}/test_file")).to eq false
+    end
+  end
+
+  it 'displays commands instead of unning them with dry-run and returns the expected code' do
+    with_repository do |repository|
+      cmd_runner = test_cmd_runner
+      cmd_runner.dry_run = true
+      expect(cmd_runner.run_cmd "echo TestContent >#{repository}/test_file", expected_code: 2).to eq [2, '', '']
+      expect(File.exist?("#{repository}/test_file")).to eq false
+    end
+  end
+
+  it 'returns the currently logged user' do
+    cmd_runner = test_cmd_runner
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'test_user', ''] }
+    expect(cmd_runner.whoami).to eq 'test_user'
+  end
+
+  it 'returns non-root user when user is not root' do
+    cmd_runner = test_cmd_runner
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'not_root', ''] }
+    expect(cmd_runner.root?).to eq false
+  end
+
+  it 'returns root user when user is root' do
+    cmd_runner = test_cmd_runner
+    expect(cmd_runner).to receive(:run_cmd).with('whoami', log_to_stdout: false) { [0, 'root', ''] }
+    expect(cmd_runner.root?).to eq true
+  end
+
+  it 'returns the correct executable prefix' do
+    expect(HybridPlatformsConductor::CmdRunner.executables_prefix).to eq "#{File.dirname($0)}/"
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/config_spec.rb

@@ -0,0 +1,238 @@
+describe HybridPlatformsConductor::Config do
+
+  it 'returns the hybrid-platforms dir correctly' do
+    with_platforms '' do |hybrid_platforms_dir|
+      expect(test_config.hybrid_platforms_dir).to eq hybrid_platforms_dir
+    end
+  end
+
+  it 'returns 1 defined OS image' do
+    with_platforms 'os_image :image1, \'/path/to/image1\'' do
+      expect(test_config.known_os_images).to eq [:image1]
+    end
+  end
+
+  it 'returns 1 defined OS image with its directory' do
+    with_platforms 'os_image :image1, \'/path/to/image1\'' do
+      expect(test_config.os_image_dir(:image1)).to eq '/path/to/image1'
+    end
+  end
+
+  it 'returns several defined OS images' do
+    with_platforms '
+      os_image :image1, \'/path/to/image1\'
+      os_image :image2, \'/path/to/image2\'
+    ' do
+      expect(test_config.known_os_images.sort).to eq %i[image1 image2].sort
+    end
+  end
+
+  it 'returns the tests provisioner correctly' do
+    with_platforms 'tests_provisioner :test_provisioner' do
+      expect(test_config.tests_provisioner_id).to eq :test_provisioner
+    end
+  end
+
+  it 'accesses the platform handler repositories if needed from the config' do
+    with_repository do |repository|
+      with_platforms "
+        test_platform path: '#{repository}' do |repository_path|
+          os_image :image1, \"\#{repository_path}/image_path\"
+        end
+      " do
+        expect(test_config.known_os_images.sort).to eq %i[image1].sort
+        expect(test_config.os_image_dir(:image1)).to eq "#{repository}/image_path"
+      end
+    end
+  end
+
+  it 'includes several configuration files' do
+    with_platforms '
+      os_image :image1, \'/path/to/image1\'
+      include_config_from "#{__dir__}/my_conf_1.rb"
+      include_config_from "#{__dir__}/my_conf_2.rb"
+    ' do |hybrid_platforms_dir|
+      File.write("#{hybrid_platforms_dir}/my_conf_1.rb", <<~EOS)
+        os_image :image4, '/path/to/image4'
+        include_config_from "\#{__dir__}/my_conf_3.rb"
+      EOS
+      File.write("#{hybrid_platforms_dir}/my_conf_2.rb", 'os_image :image2, \'/path/to/image2\'')
+      File.write("#{hybrid_platforms_dir}/my_conf_3.rb", 'os_image :image3, \'/path/to/image3\'')
+      expect(test_config.known_os_images.sort).to eq %i[image1 image2 image3 image4].sort
+    end
+  end
+
+  it 'applies nodes specific configuration to all nodes by default' do
+    with_platforms '
+      expect_tests_to_fail :my_test, \'Failure reason\'
+    ' do
+      expect(test_config.expected_failures).to eq [
+        {
+          nodes_selectors_stack: [],
+          reason: 'Failure reason',
+          tests: [:my_test]
+        }
+      ]
+    end
+  end
+
+  it 'filters nodes specific configuration to nodes sets in a scope' do
+    with_platforms '
+      for_nodes(%w[node1 node2 node3]) do
+        expect_tests_to_fail :my_test_1, \'Failure reason 1\'
+      end
+      expect_tests_to_fail :my_test_2, \'Failure reason 2\'
+    ' do
+      sort_proc = proc { |expected_failure_info| expected_failure_info[:reason] }
+      expect(test_config.expected_failures.sort_by(&sort_proc)).to eq [
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          reason: 'Failure reason 1',
+          tests: [:my_test_1]
+        },
+        {
+          nodes_selectors_stack: [],
+          reason: 'Failure reason 2',
+          tests: [:my_test_2]
+        }
+      ].sort_by(&sort_proc)
+    end
+  end
+
+  it 'filters nodes specific configuration in a scoped stack' do
+    with_platforms '
+      for_nodes(%w[node1 node2 node3]) do
+        expect_tests_to_fail :my_test_1, \'Failure reason 1\'
+        for_nodes(%w[node2 node3 node4]) do
+          expect_tests_to_fail :my_test_2, \'Failure reason 2\'
+        end
+      end
+    ' do
+      sort_proc = proc { |expected_failure_info| expected_failure_info[:reason] }
+      expect(test_config.expected_failures.sort_by(&sort_proc)).to eq [
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          reason: 'Failure reason 1',
+          tests: [:my_test_1]
+        },
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3], %w[node2 node3 node4]],
+          reason: 'Failure reason 2',
+          tests: [:my_test_2]
+        }
+      ].sort_by(&sort_proc)
+    end
+  end
+
+  it 'returns the expected failures correctly' do
+    with_platforms '
+      expect_tests_to_fail :my_test_1, \'Failure reason 1\'
+      expect_tests_to_fail %i[my_test_2 my_test_3], \'Failure reason 23\'
+      for_nodes(%w[node1 node2 node3]) do
+        expect_tests_to_fail :my_test_4, \'Failure reason 4\'
+      end
+    ' do
+      sort_proc = proc { |expected_failure_info| expected_failure_info[:reason] }
+      expect(test_config.expected_failures.sort_by(&sort_proc)).to eq [
+        {
+          nodes_selectors_stack: [],
+          reason: 'Failure reason 1',
+          tests: [:my_test_1]
+        },
+        {
+          nodes_selectors_stack: [],
+          reason: 'Failure reason 23',
+          tests: %i[my_test_2 my_test_3]
+        },
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          reason: 'Failure reason 4',
+          tests: [:my_test_4]
+        }
+      ].sort_by(&sort_proc)
+    end
+  end
+
+  it 'returns the retriable errors correctly' do
+    with_platforms '
+      retry_deploy_for_errors_on_stdout \'Retry stdout global\'
+      retry_deploy_for_errors_on_stderr [
+        \'Retry stderr global\',
+        /.+Retry stderr regexp global/
+      ]
+      for_nodes(%w[node1 node2 node3]) do
+        retry_deploy_for_errors_on_stdout \'Retry stdout nodes\'
+        retry_deploy_for_errors_on_stderr \'Retry stderr nodes\'
+      end
+    ' do
+      sort_proc = proc { |retriable_error_info| ((retriable_error_info[:errors_on_stdout] || []) + (retriable_error_info[:errors_on_stderr] || [])).first.to_s }
+      expect(test_config.retriable_errors.sort_by(&sort_proc)).to eq [
+        {
+          nodes_selectors_stack: [],
+          errors_on_stdout: ['Retry stdout global']
+        },
+        {
+          nodes_selectors_stack: [],
+          errors_on_stderr: ['Retry stderr global', /.+Retry stderr regexp global/]
+        },
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          errors_on_stdout: ['Retry stdout nodes']
+        },
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          errors_on_stderr: ['Retry stderr nodes']
+        }
+      ].sort_by(&sort_proc)
+    end
+  end
+
+  it 'returns the deployment schedules correctly' do
+    with_platforms '
+      deployment_schedule(IceCube::Schedule.new(Time.parse(\'2020-05-01 11:22:33 UTC\')))
+      for_nodes(%w[node1 node2 node3]) do
+        deployment_schedule(IceCube::Schedule.new(Time.parse(\'2020-05-02 22:33:44 UTC\')))
+      end
+    ' do
+      sort_proc = proc { |deployment_schedule_info| deployment_schedule_info[:schedule].to_ical }
+      expect(test_config.deployment_schedules.sort_by(&sort_proc)).to eq [
+        {
+          nodes_selectors_stack: [],
+          schedule: IceCube::Schedule.new(Time.parse('2020-05-01 11:22:33 UTC'))
+        },
+        {
+          nodes_selectors_stack: [%w[node1 node2 node3]],
+          schedule: IceCube::Schedule.new(Time.parse('2020-05-02 22:33:44 UTC'))
+        }
+      ].sort_by(&sort_proc)
+    end
+  end
+
+  it 'returns the deployment schedules correctly using the daily helper' do
+    with_platforms 'deployment_schedule(daily_at(\'11:22:33\'))' do
+      schedule = test_config.deployment_schedules.first[:schedule]
+      expect(Time.parse("#{schedule.start_time.strftime('%F')} 00:00:00")).to be <= Time.now
+      expect(schedule.start_time.strftime('%T')).to eq '11:22:33'
+      expect(schedule.recurrence_rules.first.to_hash).to eq(
+        validations: {},
+        rule_type: 'IceCube::DailyRule',
+        interval: 1
+      )
+    end
+  end
+
+  it 'returns the deployment schedules correctly using the weekly helper' do
+    with_platforms 'deployment_schedule(weekly_at(:monday, \'11:22:33\'))' do
+      schedule = test_config.deployment_schedules.first[:schedule]
+      expect(Time.parse("#{schedule.start_time.strftime('%F')} 00:00:00")).to be <= Time.now
+      expect(schedule.start_time.strftime('%T')).to eq '11:22:33'
+      expect(schedule.recurrence_rules.first.to_hash).to eq(
+        validations: { day: [1] },
+        week_start: 0,
+        rule_type: 'IceCube::WeeklyRule',
+        interval: 1
+      )
+    end
+  end
+
+end