hybrid_platforms_conductor 32.16.2 → 32.18.0

data/lib/hybrid_platforms_conductor/test_only_remote_node.rb

@@ -0,0 +1,18 @@
+module HybridPlatformsConductor
+
+  # Ancestor for all tests that should be run just on remote nodes
+  class TestOnlyRemoteNode < Test
+
+    # Limit the list of nodes for these tests.
+    #
+    # Result::
+    # * Array<String or Regex> or nil: List of nodes allowed for this test, or nil for all. Regular expressions matching node names can also be used.
+    def self.only_on_nodes
+      # Just 1 node per service and platform
+      Test.nodes_handler.prefetch_metadata_of Test.nodes_handler.known_nodes, :local_node
+      Test.nodes_handler.known_nodes.select { |node| !Test.nodes_handler.get_local_node_of(node) }
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/version.rb

@@ -1,5 +1,5 @@
 module HybridPlatformsConductor
 
-  VERSION = '32.16.2'
+  VERSION = '32.18.0'
 
 end

data/spec/hybrid_platforms_conductor_test.rb

@@ -5,6 +5,7 @@ require 'hybrid_platforms_conductor/platforms_handler'
 require 'hybrid_platforms_conductor/actions_executor'
 require 'hybrid_platforms_conductor/cmd_runner'
 require 'hybrid_platforms_conductor/deployer'
+require 'hybrid_platforms_conductor/log'
 require 'hybrid_platforms_conductor/nodes_handler'
 require 'hybrid_platforms_conductor/platform_handler'
 require 'hybrid_platforms_conductor/provisioner'
@@ -43,6 +44,8 @@ require 'hybrid_platforms_conductor_test/platform_handler_plugins/test2'
 require 'hybrid_platforms_conductor_test/report_plugin'
 require 'hybrid_platforms_conductor_test/test_action'
 require 'hybrid_platforms_conductor_test/test_connector'
+require 'hybrid_platforms_conductor_test/test_log_plugin'
+require 'hybrid_platforms_conductor_test/test_log_no_read_plugin'
 require 'hybrid_platforms_conductor_test/test_plugins/global'
 require 'hybrid_platforms_conductor_test/test_plugins/node'
 require 'hybrid_platforms_conductor_test/test_plugins/node_check'
@@ -128,16 +131,29 @@ module HybridPlatformsConductorTest
         HybridPlatformsConductorTest::TestPlugins::NodeCheck.only_on_platform_types = nil
         HybridPlatformsConductorTest::TestPlugins::NodeCheck.only_on_nodes = nil
         HybridPlatformsConductorTest::TestPlugins::SeveralChecks.runs = []
+        HybridPlatformsConductorTest::TestLogPlugin.calls = []
+        HybridPlatformsConductorTest::TestLogNoReadPlugin.calls = []
         FileUtils.rm_rf './run_logs'
         FileUtils.rm_rf './testadmin.key.pub'
         FileUtils.rm_rf '/tmp/hpc_ssh'
+        register_plugins(
+          :log,
+          {
+            test_log: HybridPlatformsConductorTest::TestLogPlugin,
+            test_log_no_read: HybridPlatformsConductorTest::TestLogNoReadPlugin
+          },
+          replace: false
+        )
         # Make sure CMDB plugin classes loaded by test framework are not added automatically
-        register_plugins(:cmdb, {
-          config: HybridPlatformsConductor::HpcPlugins::Cmdb::Config,
-          host_ip: HybridPlatformsConductor::HpcPlugins::Cmdb::HostIp,
-          host_keys: HybridPlatformsConductor::HpcPlugins::Cmdb::HostKeys,
-          platform_handlers: HybridPlatformsConductor::HpcPlugins::Cmdb::PlatformHandlers
-        })
+        register_plugins(
+          :cmdb,
+          {
+            config: HybridPlatformsConductor::HpcPlugins::Cmdb::Config,
+            host_ip: HybridPlatformsConductor::HpcPlugins::Cmdb::HostIp,
+            host_keys: HybridPlatformsConductor::HpcPlugins::Cmdb::HostKeys,
+            platform_handlers: HybridPlatformsConductor::HpcPlugins::Cmdb::PlatformHandlers
+          }
+        )
       end
     end
 

data/spec/hybrid_platforms_conductor_test/api/actions_executor/connectors/ssh/connections_spec.rb

@@ -29,7 +29,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
       end
 
       it 'creates an SSH master to 1 node not having Session Exec capabilities' do
-        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: 'false' } } }) do
+        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: false } } }) do
           with_cmd_runner_mocked(
             [
               ['which env', proc { [0, "/usr/bin/env\n", ''] }],
@@ -45,7 +45,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
       end
 
       it 'can\'t create an SSH master to 1 node not having Session Exec capabilities when hpc_interactive is false' do
-        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: 'false' } } }) do
+        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: false } } }) do
           ENV['hpc_interactive'] = 'false'
           with_cmd_runner_mocked(
             [
@@ -69,7 +69,7 @@ describe HybridPlatformsConductor::ActionsExecutor do
       it 'fails without creating exception when creating an SSH master to 1 node not having Session Exec capabilities when hpc_interactive is false and we use no_exception' do
         with_test_platform(nodes: {
           'node1' => { meta: { host_ip: '192.168.42.1' } },
-          'node2' => { meta: { host_ip: '192.168.42.2', ssh_session_exec: 'false' } },
+          'node2' => { meta: { host_ip: '192.168.42.2', ssh_session_exec: false } },
           'node3' => { meta: { host_ip: '192.168.42.3' } }
         }) do
           ENV['hpc_interactive'] = 'false'

data/spec/hybrid_platforms_conductor_test/api/deployer/config_dsl_spec.rb

@@ -3,10 +3,30 @@ describe HybridPlatformsConductor::Deployer do
   context 'checking deployer specific config DSL' do
 
     it 'declares a packaging timeout' do
-      with_repository do |repository|
-        with_platforms('packaging_timeout 666') do
-          expect(test_config.packaging_timeout_secs).to eq 666
-        end
+      with_platforms('packaging_timeout 666') do
+        expect(test_config.packaging_timeout_secs).to eq 666
+      end
+    end
+
+    it 'declares log plugins to be used' do
+      with_test_platforms(
+        { nodes: { 'node1' => {}, 'node2' => {} } },
+        false,
+        <<~EOS
+          send_logs_to %i[log_plugin_1 log_plugin_2]
+          for_nodes('node2') { send_logs_to :log_plugin_3 }
+        EOS
+      ) do
+        expect(test_config.deployment_logs).to eq [
+          {
+            nodes_selectors_stack: [],
+            log_plugins: %i[log_plugin_1 log_plugin_2]
+          },
+          {
+            nodes_selectors_stack: %w[node2],
+            log_plugins: %i[log_plugin_3]
+          }
+        ]
       end
     end
 

data/spec/hybrid_platforms_conductor_test/api/deployer/deploy_spec.rb

@@ -4,238 +4,213 @@ describe HybridPlatformsConductor::Deployer do
 
     deploy_specs_for(check_mode: false)
 
-    # Expect the test services handler to be called to deploy a given list of services
-    #
-    # 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,
-        secrets: {},
-        local_environment: false
-      ) do
-        nil
-      end
-      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, services|
-        expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, services, false) do
-          [{ bash: "echo \"Deploying on #{node}\"" }]
+    context 'checking log plugins usage' do
+
+      # Prepare the test platform with test log plugins
+      #
+      # Parameters::
+      # * *platforms_info* (Hash): The platforms info [default = {}]
+      # * *as_git* (Boolean): As a git repository? [default = false]
+      # * *additional_config* (String): Additional config [default = 'send_logs_to :test_log']
+      def with_test_platform_for_deploy_tests(platforms_info = {}, as_git = false, additional_config = 'send_logs_to :test_log')
+        with_test_platform(platforms_info, false, additional_config) do
+          yield
         end
-        expect(test_services_handler).to receive(:log_info_for).with(node, services) do
-          {
-            repo_name_0: 'platform',
-            commit_id_0: '123456',
-            commit_message_0: "Test commit for #{node}: #{services.join(', ')}"
-          }
+      end
+
+      it 'deploys correct logs information on 1 node' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
+          with_connections_mocked_on ['node'] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect_services_handler_to_deploy('node' => %w[service1 service2])
+            expect_actions_executor_runs([
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, 'node') },
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
+              # Third run, we expect logs to be uploaded on the node
+              proc { |actions_per_nodes| expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Save test logs to node' }]) }
+            ])
+            expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful', ''])
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node',
+                services: %w[service1 service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on 1 node' do
-      with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
-        with_connections_mocked_on ['node'] do
-          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
-          expect_services_handler_to_deploy('node' => %w[service1 service2])
-          expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
-            proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, 'node') },
-            # Second run, we expect the mutex to be released
-            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
-            # Third run, we expect logs to be uploaded on the node
-            proc do |actions_per_nodes|
-              # Check logs content
-              local_log_file = actions_per_nodes['node'][:scp].first[0]
-              expect(File.exist?(local_log_file)).to eq true
-              expect_logs_to_be(File.read(local_log_file), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node: service1, service2',
-                services: 'service1, service2',
-                exit_status: '0'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, 'node')
-            end
-          ])
-          expect(test_deployer.deploy_on('node')).to eq('node' => [0, 'Deploy successful', ''])
+      it 'deploys correct logs information on several nodes' do
+        with_test_platform_for_deploy_tests({ nodes: {
+          'node1' => { services: %w[service1] },
+          'node2' => { services: %w[service2] }
+        } }, true) do
+          with_connections_mocked_on %w[node1 node2] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect_services_handler_to_deploy(
+              'node1' => %w[service1],
+              'node2' => %w[service2]
+            )
+            expect_actions_executor_runs([
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, %w[node1 node2]) },
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, %w[node1 node2]) },
+              # Third run, we expect logs to be uploaded on the node
+              proc do |actions_per_nodes|
+                expect(actions_per_nodes).to eq(
+                  'node1' => [{ bash: 'echo Save test logs to node1' }],
+                  'node2' => [{ bash: 'echo Save test logs to node2' }]
+                )
+              end
+            ])
+            expect(test_deployer.deploy_on(%w[node1 node2])).to eq(
+              'node1' => [0, 'Deploy successful', ''],
+              'node2' => [0, 'Deploy successful', '']
+            )
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node1',
+                services: %w[service1],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node1: service1',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              },
+              {
+                method: :actions_to_save_logs,
+                node: 'node2',
+                services: %w[service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node2: service2',
+                  user: 'test_user'
+                },
+                exit_status: 0,
+                stdout: 'Deploy successful',
+                stderr: ''
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on several nodes' do
-      with_test_platform({ nodes: {
-        'node1' => { services: %w[service1] },
-        'node2' => { services: %w[service2] }
-      } }, true) do
-        with_connections_mocked_on %w[node1 node2] do
-          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
-          expect_services_handler_to_deploy(
-            'node1' => %w[service1],
-            'node2' => %w[service2]
-          )
-          expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
-            proc { |actions_per_nodes| expect_actions_to_deploy_on(actions_per_nodes, %w[node1 node2]) },
-            # Second run, we expect the mutex to be released
-            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, %w[node1 node2]) },
-            # Third run, we expect logs to be uploaded on the node
-            proc do |actions_per_nodes|
-              # Check logs content
-              local_log_file1 = actions_per_nodes['node1'][:scp].first[0]
-              expect(File.exist?(local_log_file1)).to eq true
-              expect_logs_to_be(File.read(local_log_file1), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node1: service1',
-                services: 'service1',
-                exit_status: '0'
-              )
-              local_log_file2 = actions_per_nodes['node2'][:scp].first[0]
-              expect(File.exist?(local_log_file2)).to eq true
-              expect_logs_to_be(File.read(local_log_file2), 'Deploy successful', '',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node2: service2',
-                services: 'service2',
-                exit_status: '0'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, %w[node1 node2])
-            end
-          ])
-          expect(test_deployer.deploy_on(%w[node1 node2])).to eq(
-            'node1' => [0, 'Deploy successful', ''],
-            'node2' => [0, 'Deploy successful', '']
-          )
+      it 'deploys correct logs information on 1 node even when there is a failing deploy' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
+          with_connections_mocked_on ['node'] do
+            test_actions_executor.connector(:ssh).ssh_user = 'test_user'
+            expect_services_handler_to_deploy('node' => %w[service1 service2])
+            expect_actions_executor_runs([
+              # First run, we expect the mutex to be setup, and the deployment actions to be run
+              proc do |actions_per_nodes|
+                expect_actions_to_deploy_on(
+                  actions_per_nodes,
+                  'node',
+                  mocked_result: { 'node' => [:failed_action, 'Failed deploy stdout', 'Failed deploy stderr'] }
+                )
+              end,
+              # Second run, we expect the mutex to be released
+              proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
+              # Third run, we expect logs to be uploaded on the node
+              proc { |actions_per_nodes| expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Save test logs to node' }]) }
+            ])
+            expect(test_deployer.deploy_on('node')).to eq('node' => [:failed_action, 'Failed deploy stdout', 'Failed deploy stderr'])
+            expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+              {
+                method: :actions_to_save_logs,
+                node: 'node',
+                services: %w[service1 service2],
+                deployment_info: {
+                  repo_name_0: 'platform',
+                  commit_id_0: '123456',
+                  commit_message_0: 'Test commit for node: service1, service2',
+                  user: 'test_user'
+                },
+                exit_status: :failed_action,
+                stdout: 'Failed deploy stdout',
+                stderr: 'Failed deploy stderr'
+              }
+            ]
+          end
         end
       end
-    end
 
-    it 'deploys correct logs information on 1 node even when there is a failing deploy' do
-      with_test_platform({ nodes: { 'node' => { services: %w[service1 service2] } } }, true) do
-        with_connections_mocked_on ['node'] do
-          test_actions_executor.connector(:ssh).ssh_user = 'test_user'
-          expect_services_handler_to_deploy('node' => %w[service1 service2])
+      it 'gets deployment info from log plugins' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }) do |repository|
           expect_actions_executor_runs([
-            # First run, we expect the mutex to be setup, and the deployment actions to be run
+            # Expect the actions to get log files
             proc do |actions_per_nodes|
-              expect_actions_to_deploy_on(
-                actions_per_nodes,
-                'node',
-                mocked_result: { 'node' => [:failed_action, "Failed deploy stdout\n", "Failed deploy stderr\n"] }
-              )
-            end,
-            # Second run, we expect the mutex to be released
-            proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, 'node') },
-            # Third run, we expect logs to be uploaded on the node
-            proc do |actions_per_nodes|
-              # Check logs content
-              local_log_file = actions_per_nodes['node'][:scp].first[0]
-              expect(File.exist?(local_log_file)).to eq true
-              expect_logs_to_be(File.read(local_log_file), "Failed deploy stdout\n", 'Failed deploy stderr',
-                date: /\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/,
-                user: 'test_user',
-                debug: 'No',
-                repo_name_0: 'platform',
-                commit_id_0: '123456',
-                commit_message_0: 'Test commit for node: service1, service2',
-                services: 'service1, service2',
-                exit_status: 'failed_action'
-              )
-              expect_actions_to_upload_logs(actions_per_nodes, 'node')
+              expect(actions_per_nodes).to eq('node' => [{ bash: 'echo Read logs for node' }])
+              { 'node' => [42, 'Log files read stdout', 'Log files read stderr'] }
             end
           ])
-          expect(test_deployer.deploy_on('node')).to eq('node' => [:failed_action, "Failed deploy stdout\n", "Failed deploy stderr\n"])
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: { user: 'test_user' },
+              exit_status: 666,
+              services: %w[unknown],
+              stderr: 'Deployment test stderr',
+              stdout: 'Deployment test stdout'
+            }
+          )
+          expect(HybridPlatformsConductorTest::TestLogPlugin.calls).to eq [
+            {
+              method: :actions_to_read_logs,
+              node: 'node'
+            },
+            {
+              method: :logs_for,
+              node: 'node',
+              exit_status: 42,
+              stdout: 'Log files read stdout',
+              stderr: 'Log files read stderr'
+            }
+          ]
         end
       end
-    end
-
-    it 'gets deployment info from log files' do
-      with_test_platform({ nodes: { 'node' => {} } }) do |repository|
-        expect_actions_executor_runs([
-          # Expect the actions to get log files
-          proc do |actions_per_nodes|
-            expect(actions_per_nodes).to eq('node' => { remote_bash: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' })
-            { 'node' => [0, "Property1: Value1\nProperty2: Value2", ''] }
-          end
-        ])
-        expect(test_deployer.deployment_info_from('node')).to eq(
-          'node' => {
-            Property1: 'Value1',
-            Property2: 'Value2'
-          }
-        )
-      end
-    end
 
-    it 'gets deployment info with some properties converted from log files' do
-      with_test_platform({ nodes: { 'node' => {} } }) do |repository|
-        expect_actions_executor_runs([
-          # Expect the actions to get log files
-          proc do |actions_per_nodes|
-            expect(actions_per_nodes).to eq('node' => { remote_bash: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' })
-            { 'node' => [0, <<~EOS, ''] }
-              date: Thu Nov 23 18:43:01 UTC 2017
-              debug: Yes
-              diff_files_0: file1, file2, file3
-              services: service1, service2, service3
-            EOS
-          end
-        ])
-        expect(test_deployer.deployment_info_from('node')).to eq(
-          'node' => {
-            date: Time.parse('2017-11-23 18:43:01 UTC'),
-            debug: true,
-            diff_files_0: %w[file1 file2 file3],
-            services: %w[service1 service2 service3]
-          }
-        )
-      end
-    end
-
-    it 'gets deployment info from several log files' do
-      with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
-        expect_actions_executor_runs([
-          # Expect the actions to get log files
-          proc do |actions_per_nodes|
-            expect(actions_per_nodes).to eq(
-              'node1' => { remote_bash: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' },
-              'node2' => { remote_bash: 'cd /var/log/deployments && ls -t | head -1 | xargs sed \'/===== STDOUT =====/q\'' }
-            )
+      it 'gets deployment info from log plugins not having actions_to_read_logs' do
+        with_test_platform_for_deploy_tests({ nodes: { 'node' => {} } }, false, 'send_logs_to :test_log_no_read') do |repository|
+          expect(test_deployer.deployment_info_from('node')).to eq(
+            'node' => {
+              deployment_info: { user: 'test_user' },
+              exit_status: 666,
+              services: %w[unknown],
+              stderr: 'Deployment test stderr',
+              stdout: 'Deployment test stdout'
+            }
+          )
+          expect(HybridPlatformsConductorTest::TestLogNoReadPlugin.calls).to eq [
             {
-              'node1' => [0, "Property1: Value1\nProperty2: Value2", ''],
-              'node2' => [0, "Property3: Value3\nProperty4: Value4", '']
+              method: :logs_for,
+              node: 'node',
+              exit_status: nil,
+              stdout: nil,
+              stderr: nil
             }
-          end
-        ])
-        expect(test_deployer.deployment_info_from(%w[node1 node2])).to eq(
-          'node1' => {
-            Property1: 'Value1',
-            Property2: 'Value2'
-          },
-          'node2' => {
-            Property3: 'Value3',
-            Property4: 'Value4'
-          }
-        )
+          ]
+        end
       end
+
     end
 
   end