hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/helpers/reports_handler_helpers.rb

@@ -0,0 +1,29 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module ReportsHandlerHelpers
+
+      # Register reports plugins in a Reports Handler instance
+      #
+      # Parameters::
+      # * *reports_handler* (ReportsHandler): The Reports Handler instance that need the plugins
+      # * *reports_plugins* (Hash<Symbol, Class>): List of report plugins, per test name
+      def register_report_plugins(reports_handler, reports_plugins)
+        reports_handler.instance_variable_set(:@reports_plugins, reports_plugins)
+      end
+
+      # Get a test ReportsHandler
+      #
+      # Result::
+      # * ReportsHandler: ReportsHandler on which we can do testing
+      def test_reports_handler
+        @reports_handler = HybridPlatformsConductor::ReportsHandler.new logger: logger, logger_stderr: logger, config: test_config, platforms_handler: test_platforms_handler, nodes_handler: test_nodes_handler unless @reports_handler
+        @reports_handler
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/services_handler_helpers.rb

@@ -0,0 +1,20 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module ServicesHandlerHelpers
+
+      # Get a test ServicesHandler
+      #
+      # Result::
+      # * ServicesHandler: ServicesHandler on which we can do testing
+      def test_services_handler
+        @services_handler = HybridPlatformsConductor::ServicesHandler.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, platforms_handler: test_platforms_handler, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor unless @services_handler
+        @services_handler
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/helpers/tests_runner_helpers.rb

@@ -0,0 +1,38 @@
+module HybridPlatformsConductorTest
+
+  module Helpers
+
+    module TestsRunnerHelpers
+
+      # Register test plugins in a tests runner instance
+      #
+      # Parameters::
+      # * *tests_runner* (TestsRunner): The Tests Runner instance that need the plugins
+      # * *tests_plugins* (Hash<Symbol, Class>): List of tests plugins, per test name
+      def register_test_plugins(tests_runner, tests_plugins)
+        tests_runner.instance_variable_set(:@tests_plugins, tests_plugins)
+      end
+
+      # Register tests report plugins in a tests runner instance
+      #
+      # Parameters::
+      # * *tests_runner* (TestsRunner): The Tests Runner instance that need the plugin
+      # * *tests_report_plugins* (Hash<Symbol, Class>): List of tests plugins, per test name
+      def register_tests_report_plugins(tests_runner, tests_report_plugins)
+        tests_runner.instance_variable_set(:@reports_plugins, tests_report_plugins)
+      end
+
+      # Get a test Tests Runner
+      #
+      # Result::
+      # * Deployer: Tests Runner on which we can do testing
+      def test_tests_runner
+        @tests_runner = HybridPlatformsConductor::TestsRunner.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, platforms_handler: test_platforms_handler, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor, deployer: test_deployer unless @tests_runner
+        @tests_runner
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/mocked_lib/my_test_gem/hpc_plugins/test_plugin_type/test_plugin_id1.rb

@@ -0,0 +1,22 @@
+module HybridPlatformsConductorTest
+
+  module MockedLib
+
+    module MyTestGem
+
+      module HpcPlugins
+
+        module TestPluginType
+
+          class TestPluginId1 < HybridPlatformsConductor::TestPluginType
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/mocked_lib/my_test_gem/hpc_plugins/test_plugin_type/test_plugin_id2.rb

@@ -0,0 +1,22 @@
+module HybridPlatformsConductorTest
+
+  module MockedLib
+
+    module MyTestGem
+
+      module HpcPlugins
+
+        module TestPluginType
+
+          class TestPluginId2 < HybridPlatformsConductor::TestPluginType
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/mocked_lib/my_test_gem2/sub_dir/hpc_plugins/test_plugin_type/test_plugin_id3.rb

@@ -0,0 +1,26 @@
+module HybridPlatformsConductorTest
+
+  module MockedLib
+
+    module MyTestGem2
+
+      module SubDir
+
+        module HpcPlugins
+
+          module TestPluginType
+
+            class TestPluginId3 < HybridPlatformsConductor::TestPluginType
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/mocked_lib/my_test_gem2/sub_dir/hpc_plugins/test_plugin_type2/test_plugin_id4.rb

@@ -0,0 +1,26 @@
+module HybridPlatformsConductorTest
+
+  module MockedLib
+
+    module MyTestGem2
+
+      module SubDir
+
+        module HpcPlugins
+
+          module TestPluginType2
+
+            class TestPluginId4 < HybridPlatformsConductor::TestPluginType2
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/platform_handler_plugins/test.rb

@@ -0,0 +1,225 @@
+module HybridPlatformsConductorTest
+
+  module PlatformHandlerPlugins
+
+    # Fake PlatformHandler that tests can pilot to check that the components of the Conductor behave correctly with plugins
+    class Test < HybridPlatformsConductor::PlatformHandler
+
+      class << self
+
+        # Platform properties, per platform name.
+        # Pilot this variable in the test cases to tune the behaviour of the TestPlatformHandler instances.
+        # Properties can be:
+        # * *nodes* (Hash< String, Hash<Symbol,Object> >): List of nodes, and their associated info (per node name) [default: {}]:
+        #   * *meta* (Hash<String,Object>): JSON object storing metadata about this node
+        #   * *services* (Array<String>): Services bound to this node
+        #   * *deploy_data* (String or nil): Data to be deployed, or nil to not deploy for real [default: nil]
+        # * *nodes_lists* (Hash< String, Array< String > >): Nodes lists, per list name [default: {}]
+        # * *deployable_services* (Array<String>): List of deployable services [default: []]
+        # * *package* (Proc): Code called when the plugin has to package a repository
+        # * *prepare_for_deploy* (Proc): Code called when the plugin has to prepare a deployment
+        # * *parse_deploy_output* (Proc): Code called when the plugin needs to parse some deploy output
+        # * *impacted_nodes* (Array<String>): Impacted nodes returned by impacts_from
+        # * *impacted_services* (Array<String>): Impacted services returned by impacts_from
+        # * *impacted_global* (Boolean): Impacted global returned by impacts_from
+        # Hash<String, Hash<Symbol,Object> >
+        attr_accessor :platforms_info
+
+        # Reset variables, so that they don't interfere between tests
+        def reset
+          @platforms_info = {}
+        end
+
+      end
+
+      attr_reader :files_diffs
+
+      # Register test classes
+      # [API] - This method is optional
+      #
+      # Result::
+      # * Hash<Symbol,Class>: A list of tests classes (that should inherit from Tests::Test), per test name
+      def tests
+        platform_info.key?(:tests) ? platform_info[:tests] : {}
+      end
+
+      # Get the list of known nodes.
+      # [API] - This method is mandatory.
+      #
+      # Result::
+      # * Array<String>: List of node names
+      def known_nodes
+        platform_info[:nodes].keys
+      end
+
+      # Get the list of known nodes lists names.
+      # [API] - This method is optional.
+      #
+      # Result::
+      # * Array<String>: List of nodes lists' names
+      def known_nodes_lists
+        platform_info[:nodes_lists].keys
+      end
+
+      # Get the list of nodes selectors belonging to a nodes list
+      # [API] - This method is optional unless known_nodes_lists has been defined.
+      #
+      # Parameters::
+      # * *nodes_list* (String): Name of the nodes list
+      # Result::
+      # * Array<Object>: List of nodes selectors
+      def nodes_selectors_from_nodes_list(nodes_list_name)
+        platform_info[:nodes_lists][nodes_list_name]
+      end
+
+      # Get the metadata of a given node.
+      # [API] - This method is mandatory.
+      #
+      # Parameters::
+      # * *node* (String): Node to read metadata from
+      # Result::
+      # * Hash<String,Object>: The corresponding metadata (as a JSON object)
+      def metadata_for(node)
+        node_info(node)[:meta] || {}
+      end
+
+      # Return the services for a given node
+      # [API] - This method is mandatory.
+      #
+      # Parameters::
+      # * *node* (String): node to read configuration from
+      # Result::
+      # * Array<String>: The corresponding services
+      def services_for(node)
+        node_info(node)[:services]
+      end
+
+      # Get the list of services we can deploy
+      # [API] - This method is mandatory.
+      #
+      # Result::
+      # * Array<String>: The corresponding services
+      def deployable_services
+        platform_info.key?(:deployable_services) ? platform_info[:deployable_services] : []
+      end
+
+      # Package the repository, ready to be deployed on artefacts or directly to a node.
+      # [API] - This method is mandatory.
+      # [API] - @cmd_runner is accessible.
+      # [API] - @actions_executor is accessible.
+      #
+      # Parameters::
+      # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
+      # * *secrets* (Hash): Secrets to be used for deployment
+      # * *local_environment* (Boolean): Are we deploying to a local environment?
+      def package(services:, secrets:, local_environment:)
+        platform_info[:package].call(services: services, secrets: secrets, local_environment: local_environment) if platform_info.key?(:package)
+      end
+
+      # Prepare deployments.
+      # This method is called just before getting and executing the actions to be deployed.
+      # It is called once per platform.
+      # [API] - This method is optional.
+      # [API] - @cmd_runner is accessible.
+      # [API] - @actions_executor is accessible.
+      #
+      # Parameters::
+      # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
+      # * *secrets* (Hash): Secrets to be used for deployment
+      # * *local_environment* (Boolean): Are we deploying to a local environment?
+      # * *why_run* (Boolean): Are we deploying in why-run mode?
+      def prepare_for_deploy(services:, secrets:, local_environment:, why_run:)
+        platform_info[:prepare_for_deploy].call(services: services, secrets: secrets, local_environment: local_environment, why_run: why_run) if platform_info.key?(:prepare_for_deploy)
+      end
+
+      # Get the list of actions to perform to deploy on a given node.
+      # Those actions can be executed in parallel with other deployments on other nodes. They must be thread safe.
+      # [API] - This method is mandatory.
+      # [API] - @cmd_runner is accessible.
+      # [API] - @actions_executor is accessible.
+      #
+      # Parameters::
+      # * *node* (String): Node to deploy on
+      # * *service* (String): Service to be deployed
+      # * *use_why_run* (Boolean): Do we use a why-run mode? [default = true]
+      # Result::
+      # * Array< Hash<Symbol,Object> >: List of actions to be done
+      def actions_to_deploy_on(node, service, use_why_run: true)
+        if !use_why_run && node_info(node)[:deploy_data]
+          [{ remote_bash: "echo \"#{node_info(node)[:deploy_data]}\" >deployed_file ; echo \"Real deployment done on #{node}\"" }]
+        else
+          [{ bash: "echo \"#{use_why_run ? 'Checking' : 'Deploying'} #{service} (#{name}) on #{node}\"" }]
+        end
+      end
+
+      # Parse stdout and stderr of a given deploy run and get the list of tasks with their status
+      # [API] - This method is mandatory.
+      #
+      # Parameters::
+      # * *stdout* (String): stdout to be parsed
+      # * *stderr* (String): stderr to be parsed
+      # Result::
+      # * Array< Hash<Symbol,Object> >: List of task properties. The following properties should be returned, among free ones:
+      #   * *name* (String): Task name
+      #   * *status* (Symbol): Task status. Should be on of:
+      #     * *:changed*: The task has been changed
+      #     * *:identical*: The task has not been changed
+      #   * *diffs* (String): Differences, if any
+      def parse_deploy_output(stdout, stderr)
+        platform_info[:parse_deploy_output].call(stdout, stderr) if platform_info.key?(:parse_deploy_output)
+      end
+
+      # Get the list of impacted nodes and services from a files diff.
+      # [API] - This method is optional
+      #
+      # Parameters::
+      # * *files_diffs* (Hash< String, Hash< Symbol, Object > >): List of diffs info, per file name having a diff. Diffs info have the following properties:
+      #   * *moved_to* (String): The new file path, in case it has been moved [optional]
+      #   * *diff* (String): The diff content
+      # Result::
+      # * Array<String>: The list of nodes impacted by this diff
+      # * Array<String>: The list of services impacted by this diff
+      # * Boolean: Are there some files that have a global impact (meaning all nodes are potentially impacted by this diff)?
+      def impacts_from(files_diffs)
+        @files_diffs = files_diffs
+        if platform_info.key?(:impacted_nodes) || platform_info.key?(:impacted_services) || platform_info.key?(:impacted_global)
+          [
+            platform_info[:impacted_nodes] || [],
+            platform_info[:impacted_services] || [],
+            platform_info[:impacted_global] || false
+          ]
+        else
+          super
+        end
+      end
+
+      private
+
+      # Return the platform info
+      #
+      # Result::
+      # * Hash<Symbol, Object>: Platform info (check TestPlatformHandler#platforms_info to know about properties)
+      def platform_info
+        {
+          nodes: {},
+          nodes_lists: {},
+        }.merge(HybridPlatformsConductorTest::PlatformHandlerPlugins::Test.platforms_info[name])
+      end
+
+      # Return the node info of a given node
+      #
+      # Parameters::
+      # * *node* (String): Node to get info for
+      # Result::
+      # * Hash<Symbol, Object>: Platform info (check TestPlatformHandler#platforms_info to know about properties)
+      def node_info(node)
+        {
+          deploy_data: nil
+        }.merge(platform_info[:nodes][node] || {})
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/platform_handler_plugins/test2.rb

@@ -0,0 +1,11 @@
+module HybridPlatformsConductorTest
+
+  module PlatformHandlerPlugins
+
+    # Fake PlatformHandler that tests can pilot to check that the components of the Conductor behave correctly with plugins
+    class Test2 < PlatformHandlerPlugins::Test
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/report_plugin.rb

@@ -0,0 +1,35 @@
+module HybridPlatformsConductorTest
+
+  # Report plugin for tests
+  class ReportPlugin < HybridPlatformsConductor::Report
+
+    class << self
+
+      # Access the generated reports
+      # Array<String>
+      attr_accessor :generated_reports
+
+    end
+
+    # Give the list of supported locales by this report generator
+    # [API] - This method is mandatory.
+    #
+    # Result::
+    # * Array<Symbol>: List of supported locales
+    def self.supported_locales
+      %i[en fr]
+    end
+
+    # Create a report for a list of nodes, in a given locale
+    # [API] - This method is mandatory.
+    #
+    # Parameters::
+    # * *nodes* (Array<String>): List of nodes
+    # * *locale_code* (Symbol): The locale code
+    def report_for(nodes, locale_code)
+      ReportPlugin.generated_reports << "Report generated for #{nodes.join(', ')} in #{locale_code}"
+    end
+
+  end
+
+end