hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/api/reports_handler_spec.rb

@@ -0,0 +1,44 @@
+describe HybridPlatformsConductor::ReportsHandler do
+
+  # Setup a test platform for our reports testing
+  #
+  # Parameters::
+  # * Proc: Code called when platform is setup
+  def with_test_platform_for_reports_test
+    with_test_platform(nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {} }) do
+      register_report_plugins(test_reports_handler, report: HybridPlatformsConductorTest::ReportPlugin)
+      test_reports_handler.format = :report
+      yield
+    end
+  end
+
+  it 'delivers a simple report on all the inventory' do
+    with_test_platform_for_reports_test do
+      test_reports_handler.produce_report_for [{ all: true }]
+      expect(HybridPlatformsConductorTest::ReportPlugin.generated_reports).to eq ['Report generated for node1, node2, node3 in en']
+    end
+  end
+
+  it 'delivers a simple report on some nodes only' do
+    with_test_platform_for_reports_test do
+      test_reports_handler.produce_report_for %w[node1 node3]
+      expect(HybridPlatformsConductorTest::ReportPlugin.generated_reports).to eq ['Report generated for node1, node3 in en']
+    end
+  end
+
+  it 'delivers a simple report with a different locale' do
+    with_test_platform_for_reports_test do
+      test_reports_handler.locale = :fr
+      test_reports_handler.produce_report_for [{ all: true }]
+      expect(HybridPlatformsConductorTest::ReportPlugin.generated_reports).to eq ['Report generated for node1, node2, node3 in fr']
+    end
+  end
+
+  it 'fails when delivering a simple report with an unknown locale' do
+    with_test_platform_for_reports_test do
+      test_reports_handler.locale = :de
+      expect { test_reports_handler.produce_report_for([{ all: true }])}.to raise_error(RuntimeError, 'Unknown locale for format report: de')
+    end
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/services_handler/actions_to_deploy_spec.rb

@@ -0,0 +1,121 @@
+describe HybridPlatformsConductor::ServicesHandler do
+
+  context 'checking actions to deploy services on a node' do
+
+    # Expect actions for a deployment to match a given list
+    #
+    # Parameters::
+    # * *node* (String): Node on which we deploy
+    # * *services* (Array<String>): Services being deployed
+    # * *check* (Boolean): Are we asking for a deployment in check mode?
+    # * expected_deploys* (Array< Hash<Symbol,Object> >): Expected deployment actions:
+    #   * *node* (String): Node on which deployment should occur
+    #   * *service* (String): Service that should be deployed
+    #   * *platform* (String): Platform that should be used to deploy this service [default: 'platform']
+    #   * *check* (Boolean): Should the action be deployed in check mode? [default: false]
+    def expect_deploy_actions(node, services, check, expected_deploys)
+        actions = test_services_handler.actions_to_deploy_on(node, services, check)
+        expect(actions.size).to eq expected_deploys.size * 3
+        actions.each_slice(3).zip(expected_deploys) do |((marker_begin, action, marker_end), expected_deploy)|
+          # Check that we log the begin marker before deploying the service
+          expect(marker_begin.keys).to eq [:ruby]
+          stdout_begin = StringIO.new
+          stderr_begin = StringIO.new
+          marker_begin[:ruby].call(stdout_begin, stderr_begin)
+          expect(stdout_begin.string.strip).to eq "===== [ #{expected_deploy[:node]} / #{expected_deploy[:service]} ] - HPC Service #{expected_deploy[:check] ? 'Check' : 'Deploy' } ===== Begin"
+          expect(stderr_begin.string.strip).to eq "===== [ #{expected_deploy[:node]} / #{expected_deploy[:service]} ] - HPC Service #{expected_deploy[:check] ? 'Check' : 'Deploy' } ===== Begin"
+          # Check that the service is deployed according to our mocked PlatformHandler
+          expect(action).to eq(bash: "echo \"#{expected_deploy[:check] ? 'Checking' : 'Deploying'} #{expected_deploy[:service]} (#{expected_deploy[:platform] || 'platform'}) on #{expected_deploy[:node]}\"")
+          # Check that we log the end marker after deploying the service
+          stdout_end = StringIO.new
+          stderr_end = StringIO.new
+          marker_end[:ruby].call(stdout_end, stderr_end)
+          expect(stdout_end.string.strip).to eq "===== [ #{expected_deploy[:node]} / #{expected_deploy[:service]} ] - HPC Service #{expected_deploy[:check] ? 'Check' : 'Deploy' } ===== End"
+          expect(stderr_end.string.strip).to eq "===== [ #{expected_deploy[:node]} / #{expected_deploy[:service]} ] - HPC Service #{expected_deploy[:check] ? 'Check' : 'Deploy' } ===== End"
+        end
+    end
+
+    it 'deploys a service' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1] } },
+        deployable_services: %w[service1]
+      ) do
+        expect_deploy_actions('node', %w[service1], false, [
+          { node: 'node', service: 'service1' }
+        ])
+      end
+    end
+
+    it 'deploys a service in why-run mode' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1] } },
+        deployable_services: %w[service1]
+      ) do
+        expect_deploy_actions('node', %w[service1], true, [
+          { node: 'node', service: 'service1', check: true }
+        ])
+      end
+    end
+
+    it 'deploys several services' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1 service2] } },
+        deployable_services: %w[service1 service2]
+      ) do
+        expect_deploy_actions('node', %w[service1 service2], false, [
+          { node: 'node', service: 'service1' },
+          { node: 'node', service: 'service2' }
+        ])
+      end
+    end
+
+    it 'deploys several services from different platforms' do
+      with_test_platforms(
+        'platform1' => { nodes: { 'node' => { services: %w[service1 service2] } }, deployable_services: %w[service1] },
+        'platform2' => { nodes: {}, deployable_services: %w[service2] }
+      ) do
+        expect_deploy_actions('node', %w[service1 service2], false, [
+          { node: 'node', service: 'service1', platform: 'platform1' },
+          { node: 'node', service: 'service2', platform: 'platform2' }
+        ])
+      end
+    end
+
+    it 'deploys several services from different platforms in the correct order' do
+      with_test_platforms(
+        'platform1' => { nodes: { 'node' => { services: %w[service1 service2 service3 service4] } }, deployable_services: %w[service1] },
+        'platform2' => { nodes: {}, deployable_services: %w[service2 service3] },
+        'platform3' => { nodes: {}, deployable_services: %w[service4] }
+      ) do
+        expect_deploy_actions('node', %w[service3 service1 service4 service2], false, [
+          { node: 'node', service: 'service3', platform: 'platform2' },
+          { node: 'node', service: 'service1', platform: 'platform1' },
+          { node: 'node', service: 'service4', platform: 'platform3' },
+          { node: 'node', service: 'service2', platform: 'platform2' }
+        ])
+      end
+    end
+
+    it 'deploys only required services' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1 service2] } },
+        deployable_services: %w[service1 service2]
+      ) do
+        expect_deploy_actions('node', %w[service2], false, [
+          { node: 'node', service: 'service2' }
+        ])
+      end
+    end
+
+    it 'fails if a service can\'t be deployed' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1 service2] } },
+        deployable_services: %w[service1]
+      ) do
+        expect { test_services_handler.actions_to_deploy_on('node', %w[service2], false) }.to raise_error 'No platform is able to deploy the service service2'
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/services_handler/deploy_allowed_spec.rb

@@ -0,0 +1,142 @@
+describe HybridPlatformsConductor::ServicesHandler do
+
+  context 'checking deployment authorization' do
+
+    # Setup a test platform for our services testing
+    #
+    # Parameters::
+    # * Proc: Code called when platform is setup
+    #   * Parameters::
+    #     * *repository* (String): Platform repository path
+    def with_test_platform_for_services_test
+      with_test_platform(
+        {
+          nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+          deployable_services: %w[service1]
+        },
+        true
+      ) do |repository|
+        yield repository
+      end
+    end
+
+    # Create a commit on branch and check it out
+    #
+    # Parameters::
+    # * *repository* (String): Path to the git repository
+    def checkout_non_master_on(repository)
+      git = Git.open(repository)
+      git.branch('other_branch').checkout
+      FileUtils.touch("#{repository}/other_file")
+      git.add('other_file')
+      git.commit('Test commit')
+    end
+
+    it 'allows deployment in local environment' do
+      with_test_platform_for_services_test do
+        with_cmd_runner_mocked([]) do
+          expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: true)).to eq nil
+        end
+      end
+    end
+
+    it 'allows deployment if branch is on master' do
+      with_test_platform_for_services_test do
+        expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: false)).to eq nil
+      end
+    end
+
+    it 'allows deployment if it is not a git repository' do
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1]
+      ) do
+        expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: false)).to eq nil
+      end
+    end
+
+    it 'allows deployment if branch is on a master remote' do
+      with_test_platform_for_services_test do |repository|
+        with_repository(File.basename(repository), as_git: true) do |remote_repo|
+          git = Git.open(repository)
+          git.add_remote('another_remote', remote_repo).fetch
+          git.checkout('remotes/another_remote/master')
+          expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: false)).to eq nil
+        end
+      end
+    end
+
+    it 'allows deployment if branch is on master even if not checked-out' do
+      with_test_platform_for_services_test do |repository|
+        Git.open(repository).branch('other_branch').checkout
+        expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: false)).to eq nil
+      end
+    end
+
+    it 'refuses deployment if branch is not master' do
+      with_test_platform_for_services_test do |repository|
+        checkout_non_master_on(repository)
+        expect(test_services_handler.deploy_allowed?(services: { 'node1' => %w[service1] }, secrets: {}, local_environment: false)).to eq "The following platforms have not checked out master: #{repository}. Only master should be deployed in production."
+      end
+    end
+
+    it 'checks for master branch on all platforms before allowing deployment' do
+      with_test_platforms(
+        {
+          'platform1' => { nodes: { 'node1' => { services: %w[service1] } }, deployable_services: %w[service1] },
+          'platform2' => { nodes: { 'node2' => { services: %w[service2] } }, deployable_services: %w[service2] },
+          'platform3' => { nodes: { 'node3' => { services: %w[service3] } }, deployable_services: %w[service3] }
+        },
+        true
+      ) do |repositories|
+        expect(test_services_handler.deploy_allowed?(
+          services: { 'node1' => %w[service1], 'node2' => %w[service2], 'node3' => %w[service3] },
+          secrets: {},
+          local_environment: false
+        )).to eq nil
+      end
+    end
+
+    it 'refuses deployment if at least 1 platform is not on master' do
+      with_test_platforms(
+        {
+          'platform1' => { nodes: { 'node1' => { services: %w[service1] } }, deployable_services: %w[service1] },
+          'platform2' => { nodes: { 'node2' => { services: %w[service2] } }, deployable_services: %w[service2] },
+          'platform3' => { nodes: { 'node3' => { services: %w[service3] } }, deployable_services: %w[service3] },
+          'platform4' => { nodes: { 'node4' => { services: %w[service4] } }, deployable_services: %w[service4] }
+        },
+        true
+      ) do |repositories|
+        checkout_non_master_on(repositories['platform2'])
+        checkout_non_master_on(repositories['platform4'])
+        expect(test_services_handler.deploy_allowed?(
+          services: { 'node1' => %w[service1], 'node2' => %w[service2], 'node3' => %w[service3], 'node4' => %w[service4] },
+          secrets: {},
+          local_environment: false
+        )).to eq "The following platforms have not checked out master: #{repositories['platform2']}, #{repositories['platform4']}. Only master should be deployed in production."
+      end
+    end
+
+    it 'ignores platforms not having to be packaged to check for deployment authorization' do
+      with_test_platforms(
+        {
+          'platform1' => { nodes: { 'node1' => { services: %w[service1] } }, deployable_services: %w[service1] },
+          'platform2' => { nodes: { 'node2' => { services: %w[service2] } }, deployable_services: %w[service2] },
+          'platform3' => { nodes: { 'node3' => { services: %w[service3] } }, deployable_services: %w[service3] },
+          'platform4' => { nodes: { 'node4' => { services: %w[service4] } }, deployable_services: %w[service4] }
+        },
+        true
+      ) do |repositories|
+        checkout_non_master_on(repositories['platform2'])
+        checkout_non_master_on(repositories['platform4'])
+        expect(test_services_handler.deploy_allowed?(
+          services: { 'node1' => %w[service1 service3] },
+          secrets: {},
+          local_environment: false
+        )).to eq nil
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/services_handler/log_info_spec.rb

@@ -0,0 +1,101 @@
+describe HybridPlatformsConductor::ServicesHandler do
+
+  context 'checking logs associated to a deployment' do
+
+    it 'logs platforms info' do
+      with_test_platform(
+        nodes: { 'node' => { services: %w[service1] } },
+        deployable_services: %w[service1]
+      ) do
+        expect(test_services_handler.log_info_for('node', %w[service1])).to eq(
+          repo_name_0: 'platform'
+        )
+      end
+    end
+
+    it 'logs platforms info from a git repository' do
+      with_test_platform(
+        {
+          nodes: { 'node' => { services: %w[service1] } },
+          deployable_services: %w[service1]
+        },
+        true
+      ) do |repository|
+        expect(test_services_handler.log_info_for('node', %w[service1])).to eq(
+          commit_id_0: Git.open(repository).log.first.sha,
+          commit_message_0: 'Test commit',
+          diff_files_0: '',
+          repo_name_0: 'my_remote_platform'
+        )
+      end
+    end
+
+    it 'logs platforms info from a git repository with differing files' do
+      with_test_platform(
+        {
+          nodes: { 'node' => { services: %w[service1] } },
+          deployable_services: %w[service1]
+        },
+        true
+      ) do |repository|
+        FileUtils.touch "#{repository}/new_file"
+        expect(test_services_handler.log_info_for('node', %w[service1])).to eq(
+          commit_id_0: Git.open(repository).log.first.sha,
+          commit_message_0: 'Test commit',
+          diff_files_0: 'new_file',
+          repo_name_0: 'my_remote_platform'
+        )
+      end
+    end
+
+    it 'logs several platforms info' do
+      with_test_platforms(
+        {
+          'platform1' => { nodes: { 'node' => { services: %w[service1 service2 service3] } }, deployable_services: %w[service1] },
+          'platform2' => { nodes: {}, deployable_services: %w[service2] },
+          'platform3' => { nodes: {}, deployable_services: %w[service3] },
+        },
+        true
+      ) do |repositories|
+        expect(test_services_handler.log_info_for('node', %w[service1 service2 service3])).to eq(
+          commit_id_0: Git.open(repositories['platform1']).log.first.sha,
+          commit_message_0: 'Test commit',
+          diff_files_0: '',
+          repo_name_0: 'platform1',
+          commit_id_1: Git.open(repositories['platform2']).log.first.sha,
+          commit_message_1: 'Test commit',
+          diff_files_1: '',
+          repo_name_1: 'platform2',
+          commit_id_2: Git.open(repositories['platform3']).log.first.sha,
+          commit_message_2: 'Test commit',
+          diff_files_2: '',
+          repo_name_2: 'platform3'
+        )
+      end
+    end
+
+    it 'logs only concerned platforms info' do
+      with_test_platforms(
+        {
+          'platform1' => { nodes: { 'node' => { services: %w[service1 service2 service3] } }, deployable_services: %w[service1] },
+          'platform2' => { nodes: {}, deployable_services: %w[service2] },
+          'platform3' => { nodes: {}, deployable_services: %w[service3] },
+        },
+        true
+      ) do |repositories|
+        expect(test_services_handler.log_info_for('node', %w[service1 service3])).to eq(
+          commit_id_0: Git.open(repositories['platform1']).log.first.sha,
+          commit_message_0: 'Test commit',
+          diff_files_0: '',
+          repo_name_0: 'platform1',
+          commit_id_1: Git.open(repositories['platform3']).log.first.sha,
+          commit_message_1: 'Test commit',
+          diff_files_1: '',
+          repo_name_1: 'platform3'
+        )
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/services_handler/package_spec.rb

@@ -0,0 +1,388 @@
+describe HybridPlatformsConductor::ServicesHandler do
+
+  context 'checking packaging' do
+
+    it 'packages 1 platform' do
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq({})
+          expect(local_environment).to eq false
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: false
+        )
+      end
+    end
+
+    it 'packages 1 platform only once' do
+      nbr_calls = 0
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq({})
+          expect(local_environment).to eq false
+          nbr_calls += 1
+        end
+      ) do
+        3.times do
+          test_services_handler.package(
+            services: { 'node1' => %w[service1] },
+            secrets: {},
+            local_environment: false
+          )
+        end
+        expect(nbr_calls).to eq 1
+      end
+    end
+
+    it 'packages 1 platform only once even across different ServicesHandler instances' do
+      nbr_calls = 0
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq({})
+          expect(local_environment).to eq false
+          nbr_calls += 1
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: false
+        )
+        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
+        ).package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq 1
+      end
+    end
+
+    it 'packages 1 platform with secrets' do
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq('my_secret' => 'value')
+          expect(local_environment).to eq false
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: { 'my_secret' => 'value' },
+          local_environment: false
+        )
+      end
+    end
+
+    it 'packages 1 platform for a local environment' do
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] }, 'node2' => {}, 'node3' => {} },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq({})
+          expect(local_environment).to eq true
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: true
+        )
+      end
+    end
+
+    it 'packages several platforms' do
+      nbr_calls = {
+        'platform1' => 0,
+        'platform2' => 0,
+        'platform3' => 0
+      }
+      with_test_platforms(
+        'platform1' => {
+          nodes: { 'node1' => { services: %w[service1] } },
+          deployable_services: %w[service1],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node1' => %w[service1])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform1'] += 1
+          end
+        },
+        'platform2' => {
+          nodes: { 'node2' => { services: %w[service2] } },
+          deployable_services: %w[service2],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node2' => %w[service2])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform2'] += 1
+          end
+        },
+        'platform3' => {
+          nodes: { 'node3' => { services: %w[service3] } },
+          deployable_services: %w[service3],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node3' => %w[service3])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform3'] += 1
+          end
+        }
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1], 'node2' => %w[service2], 'node3' => %w[service3] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq(
+          'platform1' => 1,
+          'platform2' => 1,
+          'platform3' => 1
+        )
+      end
+    end
+
+    it 'packages only the concerned platforms' do
+      nbr_calls = {
+        'platform1' => 0,
+        'platform2' => 0,
+        'platform3' => 0
+      }
+      with_test_platforms(
+        'platform1' => {
+          nodes: { 'node1' => { services: %w[service1] } },
+          deployable_services: %w[service1],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node1' => %w[service1])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform1'] += 1
+          end
+        },
+        'platform2' => {
+          nodes: { 'node2' => { services: %w[service2] } },
+          deployable_services: %w[service2],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node2' => %w[service2])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform2'] += 1
+          end
+        },
+        'platform3' => {
+          nodes: { 'node3' => { services: %w[service3] } },
+          deployable_services: %w[service3],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node1' => %w[service3])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform3'] += 1
+          end
+        }
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1 service3] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq(
+          'platform1' => 1,
+          'platform2' => 0,
+          'platform3' => 1
+        )
+      end
+    end
+
+    it 'packages the platforms with only the services they can deploy' do
+      nbr_calls = {
+        'platform1' => 0,
+        'platform2' => 0,
+        'platform3' => 0
+      }
+      with_test_platforms(
+        'platform1' => {
+          nodes: { 'node' => { services: %w[service1 service2 service3 service4 service5 service6] } },
+          deployable_services: %w[service1 service2],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node' => %w[service1 service2])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform1'] += 1
+          end
+        },
+        'platform2' => {
+          nodes: {},
+          deployable_services: %w[service3 service4],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node' => %w[service3])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform2'] += 1
+          end
+        },
+        'platform3' => {
+          nodes: {},
+          deployable_services: %w[service5 service6],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node' => %w[service5 service6])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform3'] += 1
+          end
+        }
+      ) do
+        test_services_handler.package(
+          services: { 'node' => %w[service1 service2 service3 service5 service6] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq(
+          'platform1' => 1,
+          'platform2' => 1,
+          'platform3' => 1
+        )
+      end
+    end
+
+    it 'packages only the platforms that were not previously packaged' do
+      nbr_calls = {
+        'platform1' => 0,
+        'platform2' => 0,
+        'platform3' => 0
+      }
+      with_test_platforms(
+        'platform1' => {
+          nodes: { 'node1' => { services: %w[service1] } },
+          deployable_services: %w[service1],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node1' => %w[service1])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform1'] += 1
+          end
+        },
+        'platform2' => {
+          nodes: { 'node2' => { services: %w[service2] } },
+          deployable_services: %w[service2],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node2' => %w[service2])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform2'] += 1
+          end
+        },
+        'platform3' => {
+          nodes: { 'node3' => { services: %w[service3] } },
+          deployable_services: %w[service3],
+          package: proc do |services:, secrets:, local_environment:|
+            expect(services).to eq('node3' => %w[service3])
+            expect(secrets).to eq({})
+            expect(local_environment).to eq false
+            nbr_calls['platform3'] += 1
+          end
+        }
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1], 'node3' => %w[service3] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq(
+          'platform1' => 1,
+          'platform2' => 0,
+          'platform3' => 1
+        )
+        test_services_handler.package(
+          services: { 'node1' => %w[service1], 'node2' => %w[service2] },
+          secrets: {},
+          local_environment: false
+        )
+        expect(nbr_calls).to eq(
+          'platform1' => 1,
+          'platform2' => 1,
+          'platform3' => 1
+        )
+      end
+    end
+
+    it 'packages the platforms again if secrets are different' do
+      nbr_calls = 0
+      expected_secrets = {}
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] } },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq(expected_secrets)
+          expect(local_environment).to eq false
+          nbr_calls += 1
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: false
+        )
+        expected_secrets = { 'my_secret' => 'value' }
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: { 'my_secret' => 'value' },
+          local_environment: false
+        )
+        expect(nbr_calls).to eq 2
+      end
+    end
+
+    it 'packages the platforms again if local environment is different' do
+      nbr_calls = 0
+      expected_local = false
+      with_test_platform(
+        nodes: { 'node1' => { services: %w[service1] } },
+        deployable_services: %w[service1],
+        package: proc do |services:, secrets:, local_environment:|
+          expect(services).to eq('node1' => %w[service1])
+          expect(secrets).to eq({})
+          expect(local_environment).to eq expected_local
+          nbr_calls += 1
+        end
+      ) do
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: false
+        )
+        expected_local = true
+        test_services_handler.package(
+          services: { 'node1' => %w[service1] },
+          secrets: {},
+          local_environment: true
+        )
+        expect(nbr_calls).to eq 2
+      end
+    end
+
+  end
+
+end