hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/api/nodes_handler/platform_handlers_plugins_api_spec.rb

@@ -0,0 +1,60 @@
+describe HybridPlatformsConductor::NodesHandler do
+
+  context 'checking Platform Handlers plugins\' API called by NodesHandler' do
+
+    it 'returns nodes' do
+      with_test_platform(nodes: { 'node1' => {}, 'node2' => {} }) do
+        expect(test_nodes_handler.known_nodes.sort).to eq %w[node1 node2].sort
+      end
+    end
+
+    it 'returns nodes lists' do
+      with_test_platform(nodes_lists: { 'test_nodes_list' => [] }) do
+        expect(test_nodes_handler.known_nodes_lists).to eq ['test_nodes_list']
+      end
+    end
+
+    it 'returns nodes defined in a nodes lists' do
+      with_test_platform(
+        nodes: { 'node1' => {}, 'node2' => {} },
+        nodes_lists: { 'test_nodes_list' => %w[node1 node2] }
+      ) do
+        expect(test_nodes_handler.nodes_from_list('test_nodes_list').sort).to eq %w[node1 node2].sort
+      end
+    end
+
+    it 'returns nodes selectors defined in a nodes lists' do
+      with_test_platform(
+        nodes: {
+          'node10' => { services: ['test_service'] },
+          'node11' => { services: ['test_service_2'] },
+          'node20' => { services: ['test_service_3', 'test_service'] },
+          'node21' => { services: ['test_service_2'] }
+        },
+        nodes_lists: { 'test_nodes_list' => ['/node1.+/', { service: 'test_service' }] }
+      ) do
+        expect(test_nodes_handler.nodes_from_list('test_nodes_list').sort).to eq %w[node10 node11 node20].sort
+      end
+    end
+
+    it 'returns nodes defined in a nodes lists while ignoring unknown ones' do
+      with_test_platform(
+        nodes: { 'node1' => {} },
+        nodes_lists: { 'test_nodes_list' => %w[node1 node2] }
+      ) do
+        expect(test_nodes_handler.nodes_from_list('test_nodes_list', ignore_unknowns: true).sort).to eq %w[node1 node2].sort
+      end
+    end
+
+    it 'fails when returning unknown nodes defined in a nodes lists' do
+      with_test_platform(
+        nodes: { 'node1' => {} },
+        nodes_lists: { 'test_nodes_list' => %w[node1 node2] }
+      ) do
+        expect { test_nodes_handler.nodes_from_list('test_nodes_list') }.to raise_error(RuntimeError, 'Unknown nodes: node2')
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/nodes_handler/several_platforms_spec.rb

@@ -0,0 +1,58 @@
+describe HybridPlatformsConductor::NodesHandler do
+
+  context 'checking aggregations across several platforms' do
+
+    it 'returns nodes' do
+      with_test_platforms(
+        'platform1' => { nodes: { 'node1' => {}, 'node2' => {} } },
+        'platform2' => { nodes: { 'node3' => {}, 'node4' => {} } }
+      ) do
+        expect(test_nodes_handler.known_nodes.sort).to eq %w[node1 node2 node3 node4].sort
+      end
+    end
+
+    it 'fails when several platforms define the same nodes' do
+      with_test_platforms(
+        'platform1' => { nodes: { 'node1' => {}, 'node2' => {} } },
+        'platform2' => { nodes: { 'node1' => {}, 'node4' => {} } }
+      ) do
+        expect { test_nodes_handler.known_nodes }.to raise_error(RuntimeError, /Can\'t register node1/)
+      end
+    end
+
+    it 'returns nodes lists' do
+      with_test_platforms(
+        'platform1' => { nodes_lists: { 'nodeslist1' => [] } },
+        'platform2' => { nodes_lists: { 'nodeslist2' => [] } }
+      ) do
+        expect(test_nodes_handler.known_nodes_lists.sort).to eq %w[nodeslist1 nodeslist2].sort
+      end
+    end
+
+    it 'fails when several platforms define the same nodes lists' do
+      with_test_platforms(
+        'platform1' => { nodes_lists: { 'nodeslist1' => [] } },
+        'platform2' => { nodes_lists: { 'nodeslist1' => [] } }
+      ) do
+        expect { test_nodes_handler.known_nodes_lists }.to raise_error(RuntimeError, /Can\'t register nodes list nodeslist1/)
+      end
+    end
+
+    it 'returns services' do
+      with_test_platforms(
+        'platform1' => { nodes: {
+          'node1' => { services: ['service1'] },
+          'node2' => { services: ['service2'] }
+        } },
+        'platform2' => { nodes: {
+          'node3' => { services: ['service1', 'service4'] },
+          'node4' => { services: ['service3'] }
+        } }
+      ) do
+        expect(test_nodes_handler.known_services.sort).to eq %w[service1 service2 service3 service4].sort
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/platform_handler_spec.rb

@@ -0,0 +1,97 @@
+describe HybridPlatformsConductor::PlatformHandler do
+
+  it 'returns the correct platform type' do
+    with_test_platform do
+      expect(test_platforms_handler.platform('platform').platform_type).to eq :test
+    end
+  end
+
+  it 'returns the correct path' do
+    with_test_platform do
+      expect(test_platforms_handler.platform('platform').repository_path).to eq "#{Dir.tmpdir}/hpc_test/platform"
+    end
+  end
+
+  it 'returns the correct info' do
+    with_test_platform do
+      expect(test_platforms_handler.platform('platform').info).to eq(repo_name: 'platform')
+    end
+  end
+
+  it 'returns the correct name when platform is not a Git repository' do
+    with_repository('my_remote_platform', as_git: false) do |repository|
+      with_platforms "test_platform path: '#{repository}'" do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'my_remote_platform' => {} }
+        expect(test_platforms_handler.platform('my_remote_platform').name).to eq 'my_remote_platform'
+      end
+    end
+  end
+
+  it 'returns the correct name when platform is a Git repository' do
+    with_repository('my_remote_platform', as_git: true) do |repository|
+      with_platforms "test_platform path: '#{repository}'" do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'my_remote_platform' => {} }
+        expect(test_platforms_handler.platform('my_remote_platform').name).to eq 'my_remote_platform'
+      end
+    end
+  end
+
+  it 'returns the correct info when platform is a Git repository' do
+    with_repository('my_remote_platform', as_git: true) do |repository|
+      with_platforms "test_platform path: '#{repository}'" do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'my_remote_platform' => {} }
+        commit = Git.open(repository).log.first
+        expect(test_platforms_handler.platform('my_remote_platform').info).to eq(
+          repo_name: 'my_remote_platform',
+          status: {
+            added_files: [],
+            changed_files: [],
+            deleted_files: [],
+            untracked_files: []
+          },
+          commit: {
+            author: {
+              email: 'email@email.com',
+              name: 'Thats Me'
+            },
+            date: commit.date.utc,
+            id: commit.sha,
+            message: 'Test commit',
+            ref: 'master'
+          }
+        )
+      end
+    end
+  end
+
+  it 'returns the differing files in the info when platform is a Git repository' do
+    with_repository('my_remote_platform', as_git: true) do |repository|
+      with_platforms "test_platform path: '#{repository}'" do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'my_remote_platform' => {} }
+        # Make the repository be a Git repository
+        git = Git.open(repository)
+        FileUtils.touch("#{repository}/test_file_1")
+        FileUtils.touch("#{repository}/test_file_2")
+        git.add(['test_file_1', 'test_file_2'])
+        git.commit('Test commit')
+        # Make some diffs
+        FileUtils.touch("#{repository}/new_file")
+        FileUtils.touch("#{repository}/added_file")
+        git.add('added_file')
+        git.remove('test_file_1')
+        File.write("#{repository}/test_file_2", 'New content')
+        expect(test_platforms_handler.platform('my_remote_platform').info[:status]).to eq(
+          added_files: ['added_file'],
+          changed_files: ['test_file_2'],
+          deleted_files: ['test_file_1'],
+          untracked_files: ['new_file']
+        )
+      end
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/platforms_handler_spec.rb

@@ -0,0 +1,104 @@
+describe HybridPlatformsConductor::PlatformsHandler do
+
+  context 'checking config specific DSL' do
+
+    it 'returns platform directories along with platform types' do
+      with_test_platforms(
+        'platform1' => { platform_type: :test },
+        'platform2' => { platform_type: :test2 },
+        'platform3' => { platform_type: :test }
+      ) do |repositories|
+        expect(test_config.platform_dirs.keys.sort).to eq %i[test test2].sort
+        expect(test_config.platform_dirs[:test].sort).to eq [
+          repositories['platform1'],
+          repositories['platform3']
+        ].sort
+        expect(test_config.platform_dirs[:test2].sort).to eq [
+          repositories['platform2']
+        ].sort
+      end
+    end
+
+  end
+
+  it 'returns no platform types by default' do
+    with_test_platforms do
+      expect(test_platforms_handler.platform_types).to eq({})
+    end
+  end
+
+  it 'returns no platform by default' do
+    with_test_platforms do
+      expect(test_platforms_handler.known_platforms).to eq []
+    end
+  end
+
+  it 'returns defined platform types' do
+    with_test_platforms(
+      'platform1' => { platform_type: :test },
+      'platform2' => { platform_type: :test2 },
+      'platform3' => { platform_type: :test }
+    ) do
+      expect(test_platforms_handler.platform_types).to eq(
+        test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test,
+        test2: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test2
+      )
+    end
+  end
+
+  it 'returns defined platforms' do
+    with_test_platforms(
+      'platform1' => { platform_type: :test },
+      'platform2' => { platform_type: :test2 },
+      'platform3' => { platform_type: :test }
+    ) do
+      expect(test_platforms_handler.known_platforms.map(&:name).sort).to eq %w[platform1 platform2 platform3].sort
+    end
+  end
+
+  it 'fails if several platforms share the same name' do
+    with_repository('platform1') do |repository|
+      with_test_platforms(
+        {
+          'platform1' => { platform_type: :test },
+          'platform2' => { platform_type: :test2 }
+        },
+        false,
+        "test2_platform path: \'#{repository}\'"
+      ) do
+        expect { test_platforms_handler.known_platforms }.to raise_error 'Platform name platform1 is declared several times.'
+      end
+    end
+  end
+
+  it 'returns defined platforms filtered by platform type' do
+    with_test_platforms(
+      'platform1' => { platform_type: :test },
+      'platform2' => { platform_type: :test2 },
+      'platform3' => { platform_type: :test }
+    ) do
+      expect(test_platforms_handler.known_platforms(platform_type: :test).map(&:name).sort).to eq %w[platform1 platform3].sort
+    end
+  end
+
+  it 'selects a platform based on its name' do
+    with_test_platforms(
+      'platform1' => { platform_type: :test },
+      'platform2' => { platform_type: :test2 },
+      'platform3' => { platform_type: :test }
+    ) do
+      expect(test_platforms_handler.platform('platform2').name).to eq 'platform2'
+    end
+  end
+
+  it 'selects nil for an unknown platform name' do
+    with_test_platforms(
+      'platform1' => { platform_type: :test },
+      'platform2' => { platform_type: :test2 },
+      'platform3' => { platform_type: :test }
+    ) do
+      expect(test_platforms_handler.platform('platform4')).to eq nil
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/plugins_spec.rb

@@ -0,0 +1,243 @@
+# Define the base class of the test plugins
+module HybridPlatformsConductor
+
+  class TestPluginType < Plugin
+  end
+
+  class TestPluginType2 < Plugin
+  end
+
+end
+
+module HybridPlatformsConductorTest
+
+  class RandomClass < HybridPlatformsConductor::Plugin
+  end
+
+  class RandomClassWithValidation < HybridPlatformsConductor::Plugin
+
+    class << self
+
+      attr_accessor :validation_result, :validation_done
+
+      # Are dependencies met before using an instance of this plugin?
+      # This method can be overriden by any plugin
+      #
+      # Result::
+      # * Boolean: Are dependencies met before using an instance of this plugin?
+      def valid?
+        @validation_done = true
+        @validation_result
+      end
+
+    end
+
+  end
+
+  class RandomClassWithPlatformsDslExtension < HybridPlatformsConductor::Plugin
+
+    module MyPlatformsDslExtension
+
+      attr_reader :my_property
+
+      # Set property
+      #
+      # Parameters::
+      # * *value* (Integer): Value to be set
+      def set_my_property(value)
+        @my_property = value * 2
+      end
+
+    end
+
+    extend_config_dsl_with MyPlatformsDslExtension
+
+  end
+
+  class RandomClassWithPlatformsDslExtensionAndInitializer < HybridPlatformsConductor::Plugin
+
+    module MyPlatformsDslExtension
+
+      attr_reader :my_other_property
+
+      # Initializer
+      def init_my_dsl
+        @my_other_property = 42
+      end
+
+      # Set property
+      #
+      # Parameters::
+      # * *value* (Integer): Value to be set
+      def set_my_other_property(value)
+        @my_other_property += value
+      end
+
+    end
+
+    extend_config_dsl_with MyPlatformsDslExtension, :init_my_dsl
+
+  end
+
+end
+
+describe HybridPlatformsConductor::Plugins do
+
+  it 'returns no plugins by default' do
+    with_test_platform do
+      expect(HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger).keys).to eq []
+    end
+  end
+
+  it 'can register a new plugin with a given class' do
+    with_test_platform do
+      plugins = HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger)
+      plugins[:new_plugin] = HybridPlatformsConductorTest::RandomClass
+      expect(plugins.keys).to eq [:new_plugin]
+      expect(plugins[:new_plugin]).to eq HybridPlatformsConductorTest::RandomClass
+    end
+  end
+
+  it 'can register a new plugin with an initializer' do
+    with_test_platform do
+      plugins = HybridPlatformsConductor::Plugins.new(
+        :test_plugin_type,
+        init_plugin: proc do |plugin_class|
+          plugin_class.name
+        end,
+        logger: logger,
+        logger_stderr: logger
+      )
+      plugins[:new_plugin] = HybridPlatformsConductorTest::RandomClass
+      expect(plugins.keys).to eq [:new_plugin]
+      expect(plugins[:new_plugin]).to eq 'HybridPlatformsConductorTest::RandomClass'
+    end
+  end
+
+  it 'validates a plugin class before registering it' do
+    with_test_platform do
+      plugins = HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger)
+      HybridPlatformsConductorTest::RandomClassWithValidation.validation_done = false
+      HybridPlatformsConductorTest::RandomClassWithValidation.validation_result = true
+      plugins[:new_plugin] = HybridPlatformsConductorTest::RandomClassWithValidation
+      expect(plugins.keys).to eq [:new_plugin]
+      expect(plugins[:new_plugin]).to eq HybridPlatformsConductorTest::RandomClassWithValidation
+      expect(HybridPlatformsConductorTest::RandomClassWithValidation.validation_done).to eq true
+    end
+  end
+
+  it 'does not register a plugin that fails validation' do
+    with_test_platform do
+      plugins = HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger)
+      HybridPlatformsConductorTest::RandomClassWithValidation.validation_done = false
+      HybridPlatformsConductorTest::RandomClassWithValidation.validation_result = false
+      plugins[:new_plugin] = HybridPlatformsConductorTest::RandomClassWithValidation
+      expect(plugins.keys).to eq []
+      expect(HybridPlatformsConductorTest::RandomClassWithValidation.validation_done).to eq true
+    end
+  end
+
+  it 'discovers automatically plugins of a given type in the hpc_plugins directory of a gem' do
+    with_test_platform do
+      # Mock the discovery of Ruby gems
+      expect(Gem).to receive(:loaded_specs) do
+        my_test_gem_spec = double('Test gemspec for gem my_test_gem')
+        expect(my_test_gem_spec).to receive(:full_gem_path) { '__gem_full_path__' }
+        expect(Dir).to receive(:glob).with('__gem_full_path__/lib/**/*.rb') do
+          [
+            '__gem_full_path__/lib/my_test_gem/hpc_plugins/test_plugin_type/test_plugin_id1.rb'
+          ]
+        end
+        {
+          'my_test_gem' => my_test_gem_spec
+        }
+      end
+      # Alter the load path to mock an extra Rubygem
+      $LOAD_PATH.unshift "#{__dir__}/../mocked_lib"
+      begin
+        plugins = HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger)
+        expect(plugins.keys).to eq [:test_plugin_id1]
+        expect(plugins[:test_plugin_id1]).to eq HybridPlatformsConductorTest::MockedLib::MyTestGem::HpcPlugins::TestPluginType::TestPluginId1
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+  end
+
+  it 'discovers automatically several plugins of different types in the hpc_plugins directories of several gems' do
+    with_test_platform do
+      # Mock the discovery of Ruby gems
+      expect(Gem).to receive(:loaded_specs).twice do
+        my_test_gem_spec = double('Test gemspec for gem my_test_gem')
+        expect(my_test_gem_spec).to receive(:full_gem_path) { '__gem_full_path__' }
+        expect(Dir).to receive(:glob).with('__gem_full_path__/lib/**/*.rb') do
+          [
+            '__gem_full_path__/lib/my_test_gem/hpc_plugins/test_plugin_type/test_plugin_id1.rb',
+            '__gem_full_path__/lib/my_test_gem/hpc_plugins/test_plugin_type/test_plugin_id2.rb'
+          ]
+        end
+        my_test_gem2_spec = double('Test gemspec for gem my_test_gem2')
+        expect(my_test_gem2_spec).to receive(:full_gem_path) { '__gem2_full_path__' }
+        expect(Dir).to receive(:glob).with('__gem2_full_path__/lib/**/*.rb') do
+          [
+            '__gem2_full_path__/lib/my_test_gem2/sub_dir/hpc_plugins/test_plugin_type/test_plugin_id3.rb',
+            '__gem2_full_path__/lib/my_test_gem2/sub_dir/hpc_plugins/test_plugin_type2/test_plugin_id4.rb'
+          ]
+        end
+        {
+          'my_test_gem' => my_test_gem_spec,
+          'my_test_gem2' => my_test_gem2_spec
+        }
+      end
+      # Alter the load path to mock an extra Rubygem
+      $LOAD_PATH.unshift "#{__dir__}/../mocked_lib"
+      begin
+        plugins = HybridPlatformsConductor::Plugins.new(:test_plugin_type, logger: logger, logger_stderr: logger)
+        expect(plugins.keys.sort).to eq %i[test_plugin_id1 test_plugin_id2 test_plugin_id3].sort
+        expect(plugins[:test_plugin_id1]).to eq HybridPlatformsConductorTest::MockedLib::MyTestGem::HpcPlugins::TestPluginType::TestPluginId1
+        expect(plugins[:test_plugin_id2]).to eq HybridPlatformsConductorTest::MockedLib::MyTestGem::HpcPlugins::TestPluginType::TestPluginId2
+        expect(plugins[:test_plugin_id3]).to eq HybridPlatformsConductorTest::MockedLib::MyTestGem2::SubDir::HpcPlugins::TestPluginType::TestPluginId3
+        plugins2 = HybridPlatformsConductor::Plugins.new(:test_plugin_type2, logger: logger, logger_stderr: logger)
+        expect(plugins2.keys).to eq [:test_plugin_id4]
+        expect(plugins2[:test_plugin_id4]).to eq HybridPlatformsConductorTest::MockedLib::MyTestGem2::SubDir::HpcPlugins::TestPluginType2::TestPluginId4
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+  end
+
+  it 'does not discover automatically plugins from gems if asked' do
+    with_test_platform do
+      # Mock the discovery of Ruby gems
+      expect(Gem).not_to receive(:loaded_specs)
+      expect(HybridPlatformsConductor::Plugins.new(:test_plugin_type, parse_gems: false, logger: logger, logger_stderr: logger).keys).to eq []
+    end
+  end
+
+  it 'extends the Config DSL from a plugin' do
+    with_repository('platform') do |repository|
+      with_platforms("
+        test_platform path: '#{repository}'
+        set_my_property 42
+      ") do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'platform' => {} }
+        expect(test_config.my_property).to eq 84
+      end
+    end
+  end
+
+  it 'extends the Config DSL with an initializer from a plugin' do
+    with_repository('platform') do |repository|
+      with_platforms("
+        test_platform path: '#{repository}'
+        set_my_other_property 66
+      ") do
+        register_platform_handlers test: HybridPlatformsConductorTest::PlatformHandlerPlugins::Test
+        self.test_platforms_info = { 'platform' => {} }
+        expect(test_config.my_other_property).to eq 108
+      end
+    end
+  end
+
+end