hybrid_platforms_conductor 32.17.0 → 33.0.2

data/spec/hybrid_platforms_conductor_test/helpers/cmdb_helpers.rb

@@ -21,12 +21,12 @@ module HybridPlatformsConductorTest
       def register_test_cmdb(cmdb_names = [:test_cmdb])
         register_plugins(
           :cmdb,
-          Hash[cmdb_names.map do |plugin_id|
+          cmdb_names.map do |plugin_id|
             [
               plugin_id,
               HybridPlatformsConductorTest::CmdbPlugins.const_get(plugin_id.to_s.split('_').collect(&:capitalize).join.to_sym)
             ]
-          end]
+          end.to_h
         )
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/config_helpers.rb

@@ -9,7 +9,7 @@ module HybridPlatformsConductorTest
       # Result::
       # * Config: Config on which we can do testing
       def test_config
-        @config = HybridPlatformsConductor::Config.new logger: logger, logger_stderr: logger unless @config
+        @config ||= HybridPlatformsConductor::Config.new logger: logger, logger_stderr: logger
         @config
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -41,30 +41,30 @@ module HybridPlatformsConductorTest
           ssh_commands_per_connection = []
           if with_strict_host_key_checking
             ip = node_connection_info[:ip] || node_connection_info[:connection]
-            ssh_commands_once.concat([
+            ssh_commands_once.concat(
               [
-                "ssh-keyscan #{ip}",
-                proc { [0, "#{ip} ssh-rsa fake_host_key_for_#{ip}", ''] }
+                [
+                  "ssh-keyscan #{ip}",
+                  proc { [0, "#{ip} ssh-rsa fake_host_key_for_#{ip}", ''] }
+                ]
               ]
-            ])
+            )
           end
           if with_control_master_create
             control_master_created = false
             ssh_commands_per_connection << [
               if with_session_exec
-                /^.+\/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$/
+                %r{^.+/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$}
               else
                 unless ENV['hpc_interactive'] == 'false'
                   # Mock the user hitting enter as the Control Master will be created in another thread and the main thread waits for user input.
                   expect($stdin).to receive(:gets) do
                     # We have to wait for the Control Master creation thread to actually create the Control Master before hitting Enter.
-                    while !control_master_created do
-                      sleep 0.1
-                    end
+                    sleep 0.1 until control_master_created
                     "\n"
                   end
                 end
-                /^xterm -e '.+\/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$/
+                %r{^xterm -e '.+/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$}
               end,
               proc do
                 control_file = test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user])
@@ -88,13 +88,13 @@ module HybridPlatformsConductorTest
           end
           if with_control_master_check
             ssh_commands_per_connection << [
-              /^.+\/ssh -O check hpc\.#{Regexp.escape(node)}$/,
+              %r{^.+/ssh -O check hpc\.#{Regexp.escape(node)}$},
               proc { [0, '', ''] }
             ]
           end
           if with_control_master_destroy
             ssh_commands_per_connection << [
-              /^.+\/ssh -O exit hpc\.#{Regexp.escape(node)} 2>&1 \| grep -v 'Exit request sent\.'$/,
+              %r{^.+/ssh -O exit 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]))
@@ -137,8 +137,7 @@ module HybridPlatformsConductorTest
       )
         with_test_platform(
           { nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: session_exec } } } },
-          false,
-          additional_config
+          additional_config: additional_config
         ) do
           with_cmd_runner_mocked(
             [

data/spec/hybrid_platforms_conductor_test/helpers/deployer_helpers.rb

@@ -12,7 +12,7 @@ module HybridPlatformsConductorTest
       # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
       def expect_action_to_lock_node(action, node, sudo: 'sudo -u root')
         expect(action[:scp].size).to eq 1
-        expect(action[:scp].first[0]).to match /^.+\/mutex_dir$/
+        expect(action[:scp].first[0]).to match(%r{^.+/mutex_dir$})
         expect(action[:scp].first[1]).to eq '.'
         expect(action[:remote_bash]).to eq "while ! #{sudo ? "#{sudo} " : ''}./mutex_dir lock /tmp/hybrid_platforms_conductor_deploy_lock \"$(ps -o ppid= -p $$)\"; do echo -e 'Another deployment is running on #{node}. Waiting for it to finish to continue...' ; sleep 5 ; done"
       end
@@ -23,7 +23,7 @@ module HybridPlatformsConductorTest
       # * *action* (Hash<Symbol,Object>): The action to check
       # * *node* (String): The concerned node
       # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
-      def expect_action_to_unlock_node(action, node, sudo: 'sudo -u root')
+      def expect_action_to_unlock_node(action, _node, sudo: 'sudo -u root')
         expect(action).to eq(remote_bash: "#{sudo ? "#{sudo} " : ''}./mutex_dir unlock /tmp/hybrid_platforms_conductor_deploy_lock")
       end
 
@@ -40,7 +40,7 @@ module HybridPlatformsConductorTest
       # * Hash<String, [Integer or Symbol, String, String] >: Expected result of those expected actions
       def expect_actions_to_deploy_on(actions, nodes, check: false, sudo: 'sudo -u root', expected_actions: [], mocked_result: nil)
         nodes = [nodes] if nodes.is_a?(String)
-        mocked_result = Hash[nodes.map { |node| [node, [0, "#{check ? 'Check' : 'Deploy'} successful", '']] }] if mocked_result.nil?
+        mocked_result = nodes.map { |node| [node, [0, "#{check ? 'Check' : 'Deploy'} successful", '']] }.to_h if mocked_result.nil?
         expect(actions.size).to eq nodes.size
         nodes.each do |node|
           expect(actions.key?(node)).to eq true
@@ -65,81 +65,270 @@ module HybridPlatformsConductorTest
           expect(actions.key?(node)).to eq true
           expect_action_to_unlock_node(actions[node], node, sudo: sudo)
         end
-        Hash[nodes.map { |node| [node, [0, 'Release mutex successful', '']] }]
+        nodes.map { |node| [node, [0, 'Release mutex successful', '']] }.to_h
       end
 
-      # Expect a given set of actions to upload log files on a list of nodes
+      # Expect a given set of actions to upload log files on a list of nodes (using the test_log log plugin)
       #
       # Parameters::
       # * *actions* (Object): Actions
       # * *nodes* (String or Array<String>): Node (or list of nodes) that should be checked
-      # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
-      def expect_actions_to_upload_logs(actions, nodes, sudo: 'sudo -u root')
+      def expect_actions_to_upload_logs(actions, nodes)
         nodes = [nodes] if nodes.is_a?(String)
         expect(actions.size).to eq nodes.size
         nodes.each do |node|
           expect(actions.key?(node)).to eq true
-          expect(actions[node][:remote_bash]).to eq "#{sudo ? "#{sudo} " : ''}mkdir -p /var/log/deployments"
-          expect(actions[node][:scp].first[1]).to eq '/var/log/deployments'
-          expect(actions[node][:scp][:group]).to eq 'root'
-          expect(actions[node][:scp][:owner]).to eq 'root'
-          expect(actions[node][:scp][:sudo]).to eq (!sudo.nil?)
+          expect(actions[node]).to eq [{ bash: "echo Save test logs to #{node}" }]
         end
-        Hash[nodes.map { |node| [node, [0, 'Logs uploaded', '']] }]
+        nodes.map { |node| [node, [0, 'Logs uploaded', '']] }.to_h
+      end
+
+      # Get a test Deployer
+      #
+      # Result::
+      # * Deployer: Deployer on which we can do testing
+      def test_deployer
+        @deployer ||= HybridPlatformsConductor::Deployer.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor, services_handler: test_services_handler
+        @deployer
       end
 
-      # Expect some logs to have the following information.
-      # Expected logs format:
+      # Expect the test services handler to be called to deploy a given list of services
       #
-      # date: 2019-08-14 17:02:57
-      # user: muriel
-      # debug: Yes
-      # repo_name: my_remote_platform
-      # commit_id: c0d16b1b7ae286ae4a059185957e08f0ddc95517
-      # commit_message: Test commit
-      # diff_files: 
-      # ===== STDOUT =====
-      # Deploy successful
-      # ===== STDERR =====
+      # Parameters::
+      # * *services* (Hash<String, Array<String> >): List of services to be expected, per node name
+      def expect_services_handler_to_deploy(services)
+        expect(test_services_handler).to receive(:deploy_allowed?).with(
+          services: services,
+          local_environment: false
+        ).and_return(nil)
+        expect(test_services_handler).to receive(:package).with(
+          services: services,
+          secrets: {},
+          local_environment: false
+        )
+        expect(test_services_handler).to receive(:prepare_for_deploy).with(
+          services: services,
+          secrets: {},
+          local_environment: false,
+          why_run: false
+        )
+        services.each do |node, node_services|
+          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, node_services, false) do
+            [{ bash: "echo \"Deploying on #{node}\"" }]
+          end
+          expect(test_services_handler).to receive(:log_info_for).with(node, node_services) do
+            {
+              repo_name_0: 'platform',
+              commit_id_0: '123456',
+              commit_message_0: "Test commit for #{node}: #{node_services.join(', ')}"
+            }
+          end
+        end
+      end
+
+      # Get expected actions for a deployment
+      #
+      # Parameters::
+      # * *services* (Hash<String, Array<String> >): Expected nodes that should be deployed, with their corresponding services [default: { 'node' => %w[service] }]
+      # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
+      # * *check_mode* (Boolean): Are we testing in check mode? [default: @check_mode]
+      # * *mocked_deploy_result* (Hash or nil): Mocked result of the deployment actions, or nil to use the helper's default [default: nil]
+      # * *additional_expected_actions* (Array): Additional expected actions [default: []]
+      # * *expect_concurrent_actions* (Boolean): Are actions expected to be run in parallel? [default: false]
+      # * *expect_actions_timeout* (Integer or nil): Expected timeout in actions, or nil for none [default: nil]
+      def expected_actions_for_deploy_on(
+        services: { 'node' => %w[service] },
+        sudo: 'sudo -u root',
+        check_mode: @check_mode,
+        mocked_deploy_result: nil,
+        additional_expected_actions: [],
+        expect_concurrent_actions: false,
+        expect_actions_timeout: nil
+      )
+        actions = [
+          # First run, we expect the mutex to be setup, and the deployment actions to be run
+          proc do |actions_per_nodes, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+            expect(timeout).to eq expect_actions_timeout
+            expect(concurrent).to eq expect_concurrent_actions
+            expect(log_to_dir).to eq 'run_logs'
+            expect_actions_to_deploy_on(
+              actions_per_nodes,
+              services.keys,
+              check: check_mode,
+              sudo: sudo,
+              mocked_result: mocked_deploy_result,
+              expected_actions: additional_expected_actions
+            )
+          end,
+          # Second run, we expect the mutex to be released
+          proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, services.keys, sudo: sudo) }
+        ]
+        services.each do |node, node_services|
+          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, node_services, check_mode) do
+            [{ bash: "echo \"#{check_mode ? 'Checking' : 'Deploying'} on #{node}\"" }]
+          end
+        end
+        # Third run, we expect logs to be uploaded on the node (only if not check mode)
+        unless check_mode
+          services.each do |node, node_services|
+            expect(test_services_handler).to receive(:log_info_for).with(node, node_services).and_return(
+              repo_name_0: 'platform',
+              commit_id_0: '123456',
+              commit_message_0: 'Test commit'
+            )
+          end
+          actions << proc { |actions_per_nodes| expect_actions_to_upload_logs(actions_per_nodes, services.keys) }
+        end
+        actions
+      end
+
+      # Prepare a platform ready to test deployments on.
       #
       # Parameters::
-      # * *logs* (String): The logs content
-      # * *stdout* (String): Expected STDOUT
-      # * *stderr* (String): Expected STDERR
-      # * *properties* (Hash<Symbol, String or Regexp>): Expected properties values, per name. Values can be exact strings or regexps.
-      def expect_logs_to_be(logs, stdout, stderr, properties)
-        lines = logs.split("\n")
-        idx_stdout = lines.index('===== STDOUT =====')
-        expect(idx_stdout).not_to eq nil
-        idx_stderr = lines.index('===== STDERR =====')
-        expect(idx_stderr).not_to eq nil
-        logs_properties = Hash[lines[0..idx_stdout - 1].map do |property_line|
-          property_fields = property_line.split(': ')
-          [
-            property_fields.first.to_sym,
-            property_fields[1..-1].join(': ')
-          ]
-        end]
-        expect(logs_properties.size).to eq properties.size
-        properties.each do |expected_property, expected_property_value|
-          expect(logs_properties.key?(expected_property)).to eq true
-          if expected_property_value.is_a?(String)
-            expect(logs_properties[expected_property]).to eq expected_property_value
+      # * *nodes_info* (Hash): Node info to give the platform [default: 1 node having 1 service]
+      # * *expect_services_to_deploy* (Hash<String,Array<String>>): Expected services to be deployed [default: all services from nodes_info]
+      # * *expect_deploy_allowed* (Boolean): Should we expect the call to deploy_allowed? [default: true]
+      # * *expect_package* (Boolean): Should we expect packaging? [default: true]
+      # * *expect_prepare_for_deploy* (Boolean): Should we expect calls to prepare for deploy? [default: true]
+      # * *expect_connections_to_nodes* (Boolean): Should we expect connections to nodes? [default: true]
+      # * *expect_default_actions* (Boolean): Should we expect default actions? [default: true]
+      # * *expect_sudo* (String or nil): Expected sudo command, or nil if none [default: 'sudo -u root']
+      # * *expect_secrets* (Hash): Secrets to be expected during deployment [default: {}]
+      # * *expect_local_environment* (Boolean): Expected local environment flag [default: false]
+      # * *expect_additional_actions* (Array): Additional expected actions [default: []]
+      # * *expect_concurrent_actions* (Boolean): Are actions expected to be run in parallel? [default: false]
+      # * *expect_actions_timeout* (Integer or nil): Expected timeout in actions, or nil for none [default: nil]
+      # * *check_mode* (Boolean): Are we testing in check mode? [default: @check_mode]
+      # * *additional_config* (String): Additional configuration to set [default: '']
+      # * Proc: Code called once the platform is ready for testing the deployer
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_platform_to_deploy(
+        nodes_info: { nodes: { 'node' => { services: %w[service] } } },
+        expect_services_to_deploy: nodes_info[:nodes].transform_values { |node_info| node_info[:services] },
+        expect_deploy_allowed: true,
+        expect_package: true,
+        expect_prepare_for_deploy: true,
+        expect_connections_to_nodes: true,
+        expect_default_actions: true,
+        expect_sudo: 'sudo -u root',
+        expect_secrets: {},
+        expect_local_environment: false,
+        expect_additional_actions: [],
+        expect_concurrent_actions: false,
+        expect_actions_timeout: nil,
+        check_mode: @check_mode,
+        additional_config: ''
+      )
+        with_test_platform(nodes_info, as_git: !check_mode, additional_config: "#{additional_config}\nsend_logs_to :test_log") do |repository|
+          # Mock the ServicesHandler accesses
+          if !check_mode && expect_deploy_allowed
+            expect(test_services_handler).to receive(:deploy_allowed?).with(
+              services: expect_services_to_deploy,
+              local_environment: expect_local_environment
+            ).and_return(nil)
+          end
+          if expect_package
+            expect(test_services_handler).to receive(:package).with(
+              services: expect_services_to_deploy,
+              secrets: expect_secrets,
+              local_environment: expect_local_environment
+            )
+          else
+            expect(test_services_handler).not_to receive(:package)
+          end
+          if expect_prepare_for_deploy
+            expect(test_services_handler).to receive(:prepare_for_deploy).with(
+              services: expect_services_to_deploy,
+              secrets: expect_secrets,
+              local_environment: expect_local_environment,
+              why_run: check_mode
+            )
+          else
+            expect(test_services_handler).not_to receive(:prepare_for_deploy)
+          end
+          test_deployer.use_why_run = true if check_mode
+          if expect_connections_to_nodes
+            with_connections_mocked_on(expect_services_to_deploy.keys) do
+              if expect_default_actions
+                expect_actions_executor_runs(
+                  expected_actions_for_deploy_on(
+                    services: expect_services_to_deploy,
+                    check_mode: check_mode,
+                    sudo: expect_sudo,
+                    additional_expected_actions: expect_additional_actions,
+                    expect_concurrent_actions: expect_concurrent_actions,
+                    expect_actions_timeout: expect_actions_timeout
+                  )
+                )
+              end
+              yield repository
+            end
           else
-            expect(logs_properties[expected_property]).to match expected_property_value
+            yield repository
           end
         end
-        expect(lines[idx_stdout + 1..idx_stderr - 1].join("\n")).to eq stdout
-        expect(lines[idx_stderr + 1..-1].join("\n")).to eq stderr
       end
 
-      # Get a test Deployer
+      # Prepare a directory with certificates
       #
-      # Result::
-      # * Deployer: Deployer on which we can do testing
-      def test_deployer
-        @deployer = HybridPlatformsConductor::Deployer.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor, services_handler: test_services_handler unless @deployer
-        @deployer
+      # Parameters::
+      # * Proc: Code called with the directory created with a mocked certificate
+      #   * Parameters::
+      #     * *certs_dir* (String): Directory containing certificates
+      def with_certs_dir
+        with_repository do |repository|
+          certs_dir = "#{repository}/certificates"
+          FileUtils.mkdir_p certs_dir
+          File.write("#{certs_dir}/test_cert.crt", 'Hello')
+          yield certs_dir
+        end
+      end
+
+      # Prepare a platform ready to test deployments' retries on.
+      #
+      # Parameters::
+      # * *nodes_info* (Hash): Node info to give the platform [default: { nodes: { 'node' => {} } }]
+      # * *block* (Proc): Code called once the platform is ready for testing the deployer
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_platform_to_retry_deploy(nodes_info: { nodes: { 'node' => { services: %w[service] } } }, &block)
+        with_platform_to_deploy(
+          nodes_info: nodes_info,
+          expect_default_actions: false,
+          additional_config: "
+          for_nodes([#{nodes_info[:nodes].keys.map { |node| "'#{node}'" }.join(', ')}]) do
+            retry_deploy_for_errors_on_stdout [
+              'stdout non-deterministic error'
+            ]
+            retry_deploy_for_errors_on_stderr [
+              'stderr non-deterministic error',
+              /stderr regexp error \\d+/
+            ]
+          end
+          for_nodes([#{nodes_info[:nodes].keys.map { |node| "'#{node}'" }.join(', ')}]) do
+            retry_deploy_for_errors_on_stdout [
+              /stdout regexp error \\d+/
+            ]
+          end
+          ",
+          &block
+        )
+      end
+
+      # Mock a sequential list of deployments
+      #
+      # Parameters::
+      # * *statuses* (Array<Hash<String,Status> or Status>)>): List of mocked deployment statuses per node name, or just the status for the default node.
+      #   A status is a triplet [Integer or Symbol, String, String]: exit status, stdout and stderr.
+      def mock_deploys_with(statuses)
+        expect_actions_executor_runs(statuses.map do |status|
+          status = { 'node' => status } if status.is_a?(Array)
+          expected_actions_for_deploy_on(
+            services: status.keys.map { |node| [node, %w[service]] }.to_h,
+            mocked_deploy_result: status
+          )
+        end.flatten)
       end
 
     end

data/spec/hybrid_platforms_conductor_test/helpers/executables_helpers.rb

@@ -18,8 +18,8 @@ module HybridPlatformsConductorTest
         stderr_file = "#{Dir.tmpdir}/hpc_test/run.stderr"
         File.open(stdout_file, 'w') { |f| f.truncate(0) }
         File.open(stderr_file, 'w') { |f| f.truncate(0) }
-        logger_stdout = Logger.new(stdout_file, level: :info)
-        logger_stderr = Logger.new(stderr_file, level: :info)
+        test_logger_stdout = Logger.new(stdout_file, level: :info)
+        test_logger_stderr = Logger.new(stderr_file, level: :info)
         # Mock the Executable creation to redirect stdout and stderr correctly
         expect(HybridPlatformsConductor::Executable).to receive(:new).once.and_wrap_original do |original_method,
           check_options: true,
@@ -27,8 +27,8 @@ module HybridPlatformsConductorTest
           parallel_options: true,
           timeout_options: true,
           deploy_options: true,
-          original_logger: Logger.new(STDOUT, level: :info),
-          original_logger_stderr: Logger.new(STDERR, level: :info),
+          _logger: Logger.new($stdout, level: :info),
+          _logger_stderr: Logger.new($stderr, level: :info),
           &opts_block|
           original_method.call(
             check_options: check_options,
@@ -36,8 +36,8 @@ module HybridPlatformsConductorTest
             parallel_options: parallel_options,
             timeout_options: timeout_options,
             deploy_options: deploy_options,
-            logger: logger_stdout,
-            logger_stderr: logger_stderr,
+            logger: test_logger_stdout,
+            logger_stderr: test_logger_stderr,
             &opts_block
           )
         end
@@ -53,18 +53,18 @@ module HybridPlatformsConductorTest
           HybridPlatformsConductor::TestsRunner => test_tests_runner
         }
         # Make sure the tested components use the same loggers as the executable.
-        components_to_mock.values.each do |component|
+        components_to_mock.each_value do |component|
           component.stdout_device = stdout_file
           component.stderr_device = stderr_file
         end
         # Make sure that when the executable creates components it uses ours
         components_to_mock.each do |component_class, component|
-          allow(component_class).to receive(:new).once { component }
+          allow(component_class).to(receive(:new).once { component })
         end
         # Run the executable
         args.concat(['--debug']) if ENV['TEST_DEBUG'] == '1'
         ARGV.replace(args)
-        old_0 = $0
+        old_program_name = $PROGRAM_NAME
         $0 = executable
         begin
           exit_code = nil
@@ -72,10 +72,10 @@ module HybridPlatformsConductorTest
             load "#{__dir__}/../../../bin/#{executable}"
             exit_code = 0
           rescue SystemExit
-            exit_code = $!.status
+            exit_code = $ERROR_INFO.status
           end
         ensure
-          $0 = old_0
+          $0 = old_program_name
         end
         stdout = File.read(stdout_file)
         stderr = File.read(stderr_file)