hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/executables/ssh_config_spec.rb

@@ -0,0 +1,35 @@
+describe 'ssh_config executable' do
+
+  # Setup a platform for ssh_config tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_ssh_config
+    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  it 'dumps the SSH config without arguments' do
+    with_test_platform_for_ssh_config do
+      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'ssh') { '# SSH config' }
+      exit_code, stdout, stderr = run 'ssh_config'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /# SSH config/
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'dumps the SSH config with an alternate SSH executable' do
+    with_test_platform_for_ssh_config do
+      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'my_ssh') { '# SSH config' }
+      exit_code, stdout, stderr = run 'ssh_config', '--ssh-exec', 'my_ssh'
+      expect(exit_code).to eq 0
+      expect(stdout).to match /# SSH config/
+      expect(stderr).to eq ''
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/executables/test_spec.rb

@@ -0,0 +1,41 @@
+describe 'test executable' do
+
+  # Setup a platform for test tests
+  #
+  # Parameters::
+  # * Proc: Code called when the platform is setup
+  #   * Parameters::
+  #     * *repository* (String): Platform's repository
+  def with_test_platform_for_test
+    with_test_platform({ nodes: { 'node' => {} } }) do |repository|
+      yield repository
+    end
+  end
+
+  it 'executes a given test on a given node' do
+    with_test_platform_for_test do
+      expect(test_tests_runner).to receive(:run_tests).with(['node']) do
+        expect(test_tests_runner.tests).to eq [:my_test]
+        0
+      end
+      exit_code, stdout, stderr = run 'test', '--node', 'node', '--test', 'my_test'
+      expect(exit_code).to eq 0
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+  it 'fails when tests are failing' do
+    with_test_platform_for_test do
+      expect(test_tests_runner).to receive(:run_tests).with(['node']) do
+        expect(test_tests_runner.tests).to eq [:my_test]
+        1
+      end
+      exit_code, stdout, stderr = run 'test', '--node', 'node', '--test', 'my_test'
+      expect(exit_code).to eq 1
+      expect(stdout).to eq ''
+      expect(stderr).to eq ''
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/actions_executor_helpers.rb

@@ -0,0 +1,98 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module ActionsExecutorHelpers
+
+      # Return a test platform setup with test actions and test connectors
+      #
+      # Parameters::
+      # * *platform_info* (Hash<Symbol,Object>): Platform info for the test platform [default = {}]
+      # * Proc: Code called with the environment ready
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_test_platform_for_executor(platform_info = {})
+        with_test_platform(platform_info) do |repository|
+          # Register the test_action action
+          register_plugins(:action, { test_action: HybridPlatformsConductorTest::TestAction }, replace: false)
+          # Register the test_connectors, and only these ones
+          register_plugins(
+            :connector,
+            {
+              test_connector: HybridPlatformsConductorTest::TestConnector,
+              test_connector_2: HybridPlatformsConductorTest::TestConnector
+            },
+            replace: false
+          )
+          yield repository
+        end
+      end
+
+      # Define a simple environment with 1 node to perform tests on actions' plugins
+      #
+      # Parameters::
+      # * Proc: Code called with environment setup
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_test_platform_for_action_plugins
+        with_test_platform_for_executor(nodes: { 'node' => {} }) do |repository|
+          test_actions_executor.connector(:test_connector).accept_nodes = ['node']
+          yield repository
+        end
+      end
+
+      # Get the test action executions
+      #
+      # Result::
+      # * Array<Array>: Test action executions
+      def action_executions
+        HybridPlatformsConductorTest::TestAction.executions
+      end
+
+      # Expect the Actions Executor to prepare connections to a given list of nodes.
+      # Perform a check at the end that it was called correctly.
+      #
+      # Parameters::
+      # * *expected_nodes* (Array<String>): List of nodes that should have masters created
+      # * Proc: Code called with the Actions Executor mocked
+      def with_connections_mocked_on(expected_nodes)
+        expect(test_actions_executor).to receive(:with_connections_prepared_to) do |nodes, no_exception: false, &client_code|
+          expect(nodes.sort).to eq expected_nodes.sort
+          client_code.call Hash[nodes.map { |node| [node, test_actions_executor.connector(:test_connector)] }]
+        end
+        yield
+      end
+
+      # Expect Actions Executor execute_actions to be called for a given sequence of actions, and provide mocking code to execute
+      #
+      # Parameters::
+      # * *expected_runs* (Array<Proc>): List of mocking codes that should be run. Each Proc has the same signature as ActionsExecutor#execute_actions
+      def expect_actions_executor_runs(expected_runs)
+        idx_actions_executor_run = 0
+        expect(test_actions_executor).to receive(:execute_actions).exactly(expected_runs.size).times do |actions_per_nodes, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true, progress_name: 'Executing actions'|
+          logger.debug "[ Mocked ActionsExecutor ] - Run actions: #{actions_per_nodes}"
+          result =
+            if idx_actions_executor_run >= expected_runs.size
+              raise "ActionsExecutor#execute_actions has been used #{idx_actions_executor_run + 1} times, but was expected only #{expected_runs.size} times"
+            else
+              expected_runs[idx_actions_executor_run].call actions_per_nodes, timeout: timeout, concurrent: concurrent, log_to_dir: log_to_dir, log_to_stdout: log_to_stdout
+            end
+          idx_actions_executor_run += 1
+          result
+        end
+      end
+
+      # Get a test ActionsExecutor
+      #
+      # Result::
+      # * ActionsExecutor: ActionsExecutor on which we can do testing
+      def test_actions_executor
+        @actions_executor = HybridPlatformsConductor::ActionsExecutor.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler unless @actions_executor
+        @actions_executor
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/cmd_runner_helpers.rb

@@ -0,0 +1,92 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module CmdRunnerHelpers
+
+      # Run some code with some expected commands to be run by CmdRunner.
+      # Run expectations on the expected commands to be called.
+      #
+      # Parameters::
+      # * *commands* (Array< [String or Regexp, Proc] >): Expected commands that should be called on CmdRunner: the command name or regexp and the corresponding mocked code
+      #   * Parameters::
+      #     * Same parameters as CmdRunner@run_cmd
+      # * *cmd_runner* (CmdRunner): The CmdRunner to mock [default: test_cmd_runner]
+      # * Proc: Code called with the command runner mocked
+      def with_cmd_runner_mocked(commands, cmd_runner: test_cmd_runner)
+        unexpected_commands = []
+        remaining_expected_commands = commands.clone
+        # We need to protect the access to this array as the mocked commands can be called by competing threads
+        remaining_expected_commands_mutex = Mutex.new
+        allow(cmd_runner).to receive(:run_cmd) do |cmd, log_to_file: nil, log_to_stdout: true, log_stdout_to_io: nil, log_stderr_to_io: nil, expected_code: 0, timeout: nil, no_exception: false|
+          # Check the remaining expected commands
+          found_command = nil
+          found_command_code = nil
+          remaining_expected_commands_mutex.synchronize do
+            remaining_expected_commands.delete_if do |(expected_command, command_code)|
+              break unless found_command.nil?
+              if (expected_command.is_a?(String) && expected_command == cmd) || (expected_command.is_a?(Regexp) && cmd =~ expected_command)
+                found_command = expected_command
+                found_command_code = command_code
+                true
+              end
+            end
+          end
+          if found_command
+            logger.debug "[ Mocked CmdRunner ] - Calling mocked command #{cmd}"
+            mocked_exit_status, mocked_stdout, mocked_stderr = found_command_code.call(
+              cmd,
+              log_to_file: log_to_file,
+              log_to_stdout: log_to_stdout,
+              log_stdout_to_io: log_stdout_to_io,
+              log_stderr_to_io: log_stderr_to_io,
+              expected_code: expected_code,
+              timeout: timeout,
+              no_exception: no_exception
+            )
+            log_stdout =
+              if mocked_stdout.empty?
+                ''
+              else
+                stripped_stdout = mocked_stdout.strip
+                stripped_stdout.include?("\n") ? "\n----- Mocked STDOUT:\n#{mocked_stdout}" : " (Mocked STDOUT: #{stripped_stdout})"
+              end
+            log_stderr =
+              if mocked_stderr.empty?
+                ''
+              else
+                stripped_stderr = mocked_stderr.strip
+                stripped_stderr.include?("\n") ? "\n----- Mocked STDERR:\n#{mocked_stderr}" : " (Mocked STDERR: #{stripped_stderr})"
+              end
+            logger.debug "[ Mocked CmdRunner ] - Calling mocked command #{cmd} => #{mocked_exit_status}#{log_stdout}#{log_stderr}"
+            # If IOs were used, don't forget to mock them as well
+            log_stdout_to_io << mocked_stdout if !mocked_stdout.empty? && !log_stdout_to_io.nil?
+            log_stderr_to_io << mocked_stderr if !mocked_stderr.empty? && !log_stderr_to_io.nil?
+            [mocked_exit_status, mocked_stdout, mocked_stderr]
+          else
+            logger.error "[ Mocked CmdRunner ] - !!! Unexpected command run: #{cmd}"
+            unexpected_commands << cmd
+            [:unexpected_command_to_mock, '', "Could not mock unexpected command #{cmd}"]
+          end
+        end
+        yield
+        expect(unexpected_commands).to eq []
+        expect(remaining_expected_commands).to eq([]), "Expected CmdRunner commands were not run:\n#{remaining_expected_commands.map(&:first).join("\n")}"
+        # Un-mock the command runner
+        allow(cmd_runner).to receive(:run_cmd).and_call_original
+      end
+
+      # Get a test CmdRunner
+      #
+      # Result::
+      # * CmdRunner: CmdRunner on which we can do testing
+      def test_cmd_runner
+        @cmd_runner = HybridPlatformsConductor::CmdRunner.new logger: logger, logger_stderr: logger unless @cmd_runner
+        @cmd_runner
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/cmdb_helpers.rb

@@ -0,0 +1,37 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module CmdbHelpers
+
+      # Get a given CMDB instance to be tested
+      #
+      # Parameters::
+      # * *name* (Symbol): The CMDB name
+      # Result::
+      # * Cmdb: The CMDB instance
+      def cmdb(name)
+        test_nodes_handler.instance_variable_get(:@cmdbs)[name]
+      end
+
+      # Register test CMDBs in the test nodes handler as the only CMDB available
+      #
+      # Parameters::
+      # * *cmdb_names* (Array<Symbol>): The test CMDBs to register [default = [:test_cmdb]]
+      def register_test_cmdb(cmdb_names = [:test_cmdb])
+        register_plugins(
+          :cmdb,
+          Hash[cmdb_names.map do |plugin_id|
+            [
+              plugin_id,
+              HybridPlatformsConductorTest::CmdbPlugins.const_get(plugin_id.to_s.split('_').collect(&:capitalize).join.to_sym)
+            ]
+          end]
+        )
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/config_helpers.rb

@@ -0,0 +1,20 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module ConfigHelpers
+
+      # Get a test Config
+      #
+      # Result::
+      # * Config: Config on which we can do testing
+      def test_config
+        @config = HybridPlatformsConductor::Config.new logger: logger, logger_stderr: logger unless @config
+        @config
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -0,0 +1,130 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module ConnectorSshHelpers
+
+      # Get expected commands for SSH connections established for a given set of nodes.
+      # Those expected commands are meant to be directed and mocked by CmdRunner.
+      #
+      # Parameters::
+      # * *nodes_connections* (Hash<String, Hash<Symbol,Object> >): Nodes' connections info, per node name:
+      #   * *connection* (String): Connection string (fqdn, IP...) used by SSH
+      #   * *user* (String): User used by SSH
+      #   * *times* (Integer): Number of times this connection should be used [default: 1]
+      #   * *control_master_create_error* (String or nil): Error to simulate during the SSH ControlMaster creation, or nil for none [default: nil]
+      # * *with_control_master_create* (Boolean): Do we create the control master? [default: true]
+      # * *with_control_master_check* (Boolean): Do we check the control master? [default: false]
+      # * *with_control_master_destroy* (Boolean): Do we destroy the control master? [default: true]
+      # * *with_strict_host_key_checking* (Boolean): Do we use strict host key checking? [default: true]
+      # * *with_batch_mode* (Boolean): Do we use BatchMode when creating the control master? [default: true]
+      # Result::
+      # * Array< [String or Regexp, Proc] >: The expected commands that should be used, and their corresponding mocked code
+      def ssh_expected_commands_for(
+        nodes_connections,
+        with_control_master_create: true,
+        with_control_master_check: false,
+        with_control_master_destroy: true,
+        with_strict_host_key_checking: true,
+        with_batch_mode: true
+      )
+        nodes_connections.map do |node, node_connection_info|
+          node_connection_info[:times] = 1 unless node_connection_info.key?(:times)
+          ssh_commands_once = []
+          ssh_commands_per_connection = []
+          if with_strict_host_key_checking
+            ssh_commands_once.concat([
+              [
+                "ssh-keyscan #{node_connection_info[:connection]}",
+                proc { [0, "#{node_connection_info[:connection]} ssh-rsa fake_host_key_for_#{node_connection_info[:connection]}", ''] }
+              ]
+            ])
+          end
+          if with_control_master_create
+            ssh_commands_per_connection << [
+              /^.+\/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes #{Regexp.escape(node_connection_info[:user])}@hpc\.#{Regexp.escape(node)} true$/,
+              proc do
+                control_file = test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user])
+                # Fail if the ControlMaster file already exists, as would SSH do if the file is stalled
+                if File.exist?(control_file)
+                  [255, '', "Control file #{control_file} already exists"]
+                elsif node_connection_info[:control_master_create_error].nil?
+                  # Really touch a fake control file, as ssh connector checks for its existence
+                  File.write(control_file, '')
+                  [0, '', '']
+                else
+                  [255, '', node_connection_info[:control_master_create_error]]
+                end
+              end
+            ]
+          end
+          if with_control_master_check
+            ssh_commands_per_connection << [
+              /^.+\/ssh -O check #{Regexp.escape(node_connection_info[:user])}@hpc\.#{Regexp.escape(node)}$/,
+              proc { [0, '', ''] }
+            ]
+          end
+          if with_control_master_destroy
+            ssh_commands_per_connection << [
+              /^.+\/ssh -O exit #{Regexp.escape(node_connection_info[:user])}@hpc\.#{Regexp.escape(node)} 2>&1 \| grep -v 'Exit request sent\.'$/,
+              proc do
+                # Really mock the control file deletion
+                File.unlink(test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user]))
+                [1, '', '']
+              end
+            ]
+          end
+          ssh_commands_once + ssh_commands_per_connection * node_connection_info[:times]
+        end.flatten(1)
+      end
+
+      # Return the connector to be tested
+      #
+      # Result::
+      # * Connector: Connector to be tested
+      def test_connector
+        test_actions_executor.connector(:ssh)
+      end
+
+      # Get a test platform and the connector prepared the same way Actions Executor does before calling remote_* methods
+      #
+      # Parameters::
+      # * *expected_cmds* (Array< [String or Regexp, Proc] >): The expected commands that should be used, and their corresponding mocked code [default: []]
+      # * *expected_stdout* (String): Expected stdout after client code execution [default: '']
+      # * *expected_stderr* (String): Expected stderr after client code execution [default: '']
+      # * *timeout* (Integer or nil): Timeout to prepare the connector for [default: nil]
+      # * *password* (String or nil): Password to set for the node, or nil for none [default: nil]
+      # * Proc: Client code to execute testing
+      def with_test_platform_for_remote_testing(expected_cmds: [], expected_stdout: '', expected_stderr: '', timeout: nil, password: nil)
+        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } }) do
+          with_cmd_runner_mocked(
+            [
+              ['which env', proc { [0, "/usr/bin/env\n", ''] }],
+              ['ssh -V 2>&1', proc { [0, "OpenSSH_7.4p1 Debian-10+deb9u7, OpenSSL 1.0.2u  20 Dec 2019\n", ''] }]
+            ] +
+              (password ? [['sshpass -V', proc { [0, "sshpass 1.06\n", ''] }]] : []) +
+              ssh_expected_commands_for(
+                { 'node' => { connection: '192.168.42.42', user: 'test_user' } },
+                with_batch_mode: password.nil?
+              ) +
+              expected_cmds
+          ) do
+            test_connector.ssh_user = 'test_user'
+            test_connector.passwords['node'] = password if password
+            test_connector.with_connection_to(['node']) do
+              stdout = ''
+              stderr = ''
+              test_connector.prepare_for('node', timeout, stdout, stderr)
+              yield
+              expect(stdout).to eq expected_stdout
+              expect(stderr).to eq expected_stderr
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end