puppet_litmus 1.3.0 → 1.5.0

data/lib/puppet_litmus/rake_tasks.rb

@@ -210,9 +210,9 @@ namespace :litmus do
     # module_tar = Dir.glob('pkg/*.tar.gz').max_by { |f| File.mtime(f) }
     raise "Unable to find package in 'pkg/*.tar.gz'" if module_tar.nil?
 
-    install_module(inventory_hash, args[:target_node_name], module_tar, args[:module_repository])
+    install_module(inventory_hash, target_nodes, module_tar, args[:module_repository])
 
-    puts "Installed '#{module_tar}' on #{args[:target_node_name]}"
+    puts "Installed '#{module_tar}' on #{target_nodes.join(', ')}"
   end
 
   # Install the puppet modules from a source directory to nodes. It does not install dependencies.
@@ -241,10 +241,8 @@ namespace :litmus do
     include BoltSpec::Run
     module_tars.each do |module_tar|
       puts "Installing '#{module_tar}'"
-      target_nodes.each do |target_node_name|
-        install_module(inventory_hash, target_node_name, module_tar, args[:module_repository], args[:ignore_dependencies])
-        puts "Installed '#{module_tar}' on #{target_node_name}"
-      end
+      install_module(inventory_hash, target_nodes, module_tar, args[:module_repository], args[:ignore_dependencies])
+      puts "Installed '#{module_tar}' on #{target_nodes.join(', ')}"
     end
   end
 

data/lib/puppet_litmus/spec_helper_acceptance.rb

@@ -26,8 +26,14 @@ module PuppetLitmus
 
       if target_in_group(inventory_hash, ENV.fetch('TARGET_HOST', nil), 'docker_nodes')
         host = ENV.fetch('TARGET_HOST', nil)
-        set :backend, :docker
+        set :backend, :dockercli
         set :docker_container, host
+      elsif target_in_group(inventory_hash, ENV.fetch('TARGET_HOST', nil), 'lxd_nodes')
+        host = ENV.fetch('TARGET_HOST', nil)
+        set :backend, :lxd
+        set :login_shell, true
+        set :lxd_remote, node_config.dig('lxd', 'remote') unless node_config.dig('lxd', 'remote').nil?
+        set :lxd_instance, host
       elsif target_in_group(inventory_hash, ENV.fetch('TARGET_HOST', nil), 'ssh_nodes')
         set :backend, :ssh
         options = Net::SSH::Config.for(host)

data/lib/puppet_litmus/version.rb

@@ -2,5 +2,5 @@
 
 # version of this gem
 module PuppetLitmus
-  VERSION = '1.3.0'
+  VERSION = '1.5.0'
 end

data/spec/exe/fake_metadata.json

@@ -14,6 +14,13 @@
     }
   ],
   "operatingsystem_support": [
+    {
+      "operatingsystem": "AmazonLinux",
+      "operatingsystemrelease": [
+        "2",
+        "2023"
+      ]
+    },
     {
       "operatingsystem": "CentOS",
       "operatingsystemrelease": [

data/spec/exe/matrix_from_metadata_v2_spec.rb

@@ -17,12 +17,14 @@ RSpec.describe 'matrix_from_metadata_v2' do
     end
 
     it 'generates the matrix' do # rubocop:disable RSpec/ExampleLength
+      expect(result.stdout).to include('::warning::Cannot find image for CentOS-6')
       expect(result.stdout).to include('::warning::Cannot find image for Ubuntu-14.04')
       expect(github_output_content).to include(
         [
           'matrix={',
           '"platforms":[',
-          '{"label":"CentOS-6","provider":"docker","image":"litmusimage/centos:6"},',
+          '{"label":"AmazonLinux-2","provider":"docker","image":"litmusimage/amazonlinux:2"},',
+          '{"label":"AmazonLinux-2023","provider":"docker","image":"litmusimage/amazonlinux:2023"},',
           '{"label":"RedHat-8","provider":"provision_service","image":"rhel-8"},',
           '{"label":"RedHat-9","provider":"provision_service","image":"rhel-9"},',
           '{"label":"RedHat-9-arm","provider":"provision_service","image":"rhel-9-arm64"},',
@@ -39,7 +41,7 @@ RSpec.describe 'matrix_from_metadata_v2' do
       expect(github_output_content).to include(
         'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
       )
-      expect(result.stdout).to include("Created matrix with 16 cells:\n  - Acceptance Test Cells: 14\n  - Spec Test Cells: 2")
+      expect(result.stdout).to include("Created matrix with 18 cells:\n  - Acceptance Test Cells: 16\n  - Spec Test Cells: 2")
     end
   end
 
@@ -57,13 +59,15 @@ RSpec.describe 'matrix_from_metadata_v2' do
     end
 
     it 'generates the matrix without excluded platforms' do # rubocop:disable RSpec/ExampleLength
+      expect(result.stdout).to include('::warning::Cannot find image for CentOS-6')
       expect(result.stdout).to include('::warning::Cannot find image for Ubuntu-14.04')
       expect(result.stdout).to include('::warning::Ubuntu-18.04 was excluded from testing')
       expect(github_output_content).to include(
         [
           'matrix={',
           '"platforms":[',
-          '{"label":"CentOS-6","provider":"docker","image":"litmusimage/centos:6"},',
+          '{"label":"AmazonLinux-2","provider":"docker","image":"litmusimage/amazonlinux:2"},',
+          '{"label":"AmazonLinux-2023","provider":"docker","image":"litmusimage/amazonlinux:2023"},',
           '{"label":"RedHat-8","provider":"provision_service","image":"rhel-8"},',
           '{"label":"RedHat-9","provider":"provision_service","image":"rhel-9"},',
           '{"label":"RedHat-9-arm","provider":"provision_service","image":"rhel-9-arm64"},',
@@ -79,14 +83,14 @@ RSpec.describe 'matrix_from_metadata_v2' do
       expect(github_output_content).to include(
         'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
       )
-      expect(result.stdout).to include("Created matrix with 14 cells:\n  - Acceptance Test Cells: 12\n  - Spec Test Cells: 2")
+      expect(result.stdout).to include("Created matrix with 16 cells:\n  - Acceptance Test Cells: 14\n  - Spec Test Cells: 2")
     end
   end
 
   context 'with --exclude-platforms \'["ubuntu-18.04","redhat-8"]\'' do
     let(:github_output) { Tempfile.new('github_output') }
     let(:github_output_content) { github_output.read }
-    let(:result) { run_matrix_from_metadata_v2({ '--exclude-platforms' => ['ubuntu-18.04', 'ubuntu-22.04', 'redhat-8', 'redhat-9'] }) }
+    let(:result) { run_matrix_from_metadata_v2({ '--exclude-platforms' => ['amazonlinux-2', 'amazonlinux-2023', 'ubuntu-18.04', 'ubuntu-22.04', 'redhat-8', 'redhat-9'] }) }
 
     before do
       ENV['GITHUB_OUTPUT'] = github_output.path
@@ -98,6 +102,7 @@ RSpec.describe 'matrix_from_metadata_v2' do
 
     it 'generates the matrix without excluded platforms' do
       expect(result.stdout).to include('::warning::Cannot find image for Ubuntu-14.04')
+      expect(result.stdout).to include('::warning::Cannot find image for CentOS-6')
       expect(result.stdout).to include('::warning::Ubuntu-18.04 was excluded from testing')
       expect(result.stdout).to include('::warning::Ubuntu-22.04 was excluded from testing')
       expect(result.stdout).to include('::warning::RedHat-8 was excluded from testing')
@@ -105,7 +110,6 @@ RSpec.describe 'matrix_from_metadata_v2' do
         [
           'matrix={',
           '"platforms":[',
-          '{"label":"CentOS-6","provider":"docker","image":"litmusimage/centos:6"},',
           '{"label":"RedHat-9-arm","provider":"provision_service","image":"rhel-9-arm64"},',
           '{"label":"Ubuntu-22.04-arm","provider":"provision_service","image":"ubuntu-2204-lts-arm64"}',
           '],',
@@ -118,7 +122,46 @@ RSpec.describe 'matrix_from_metadata_v2' do
       expect(github_output_content).to include(
         'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
       )
-      expect(result.stdout).to include("Created matrix with 8 cells:\n  - Acceptance Test Cells: 6\n  - Spec Test Cells: 2")
+      expect(result.stdout).to include("Created matrix with 6 cells:\n  - Acceptance Test Cells: 4\n  - Spec Test Cells: 2")
+    end
+  end
+
+  context 'without arguments and GITHUB_REPOSITORY_OWNER is not puppetlabs' do
+    let(:github_output) { Tempfile.new('github_output') }
+    let(:github_output_content) { github_output.read }
+    let(:result) { run_matrix_from_metadata_v2 }
+
+    before do
+      ENV['GITHUB_OUTPUT'] = github_output.path
+      ENV['GITHUB_REPOSITORY_OWNER'] = 'aforkuser'
+    end
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix' do
+      expect(result.stdout).to include('::warning::Cannot find image for CentOS-6')
+      expect(result.stdout).to include('::warning::Cannot find image for Ubuntu-14.04')
+      expect(github_output_content).to include(
+        [
+          'matrix={',
+          '"platforms":[',
+          '{"label":"AmazonLinux-2","provider":"docker","image":"litmusimage/amazonlinux:2"},',
+          '{"label":"AmazonLinux-2023","provider":"docker","image":"litmusimage/amazonlinux:2023"},',
+          '{"label":"Ubuntu-18.04","provider":"docker","image":"litmusimage/ubuntu:18.04"},',
+          '{"label":"Ubuntu-22.04","provider":"docker","image":"litmusimage/ubuntu:22.04"}',
+          '],',
+          '"collection":[',
+          '"puppet7-nightly","puppet8-nightly"',
+          ']',
+          '}'
+        ].join
+      )
+      expect(github_output_content).to include(
+        'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
+      )
+      expect(result.stdout).to include("Created matrix with 10 cells:\n  - Acceptance Test Cells: 8\n  - Spec Test Cells: 2")
     end
   end
 end

data/spec/exe/matrix_from_metadata_v3_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'matrix_from_metadata_v3' do
+  let(:github_output) { Tempfile.new('github_output') }
+  let(:github_output_content) { github_output.read }
+  let(:github_repository_owner) { nil }
+
+  before do
+    ENV['GITHUB_ACTIONS'] = '1'
+    ENV['GITHUB_OUTPUT'] = github_output.path
+    ENV['GITHUB_REPOSITORY_OWNER'] = github_repository_owner
+  end
+
+  context 'without arguments' do
+    let(:result) { run_matrix_from_metadata_v3 }
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix' do
+      matrix = [
+        'matrix={',
+        '"platforms":[',
+        '{"label":"AmazonLinux-2","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2","runner":"ubuntu-20.04"},',
+        '{"label":"AmazonLinux-2023","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2023","runner":"ubuntu-20.04"},',
+        '{"label":"Ubuntu-18.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:18.04","runner":"ubuntu-20.04"},',
+        '{"label":"Ubuntu-22.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:22.04","runner":"ubuntu-latest"}',
+        '],',
+        '"collection":[',
+        '"puppet7-nightly","puppet8-nightly"',
+        ']',
+        '}'
+      ].join
+      expect(result.stdout).to include(
+        '::warning::CentOS-6 no provisioner found',
+        '::warning::Ubuntu-14.04 no provisioner found',
+        '::group::matrix',
+        '::group::spec_matrix'
+      )
+      expect(github_output_content).to include(matrix)
+      expect(github_output_content).to include('spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}')
+    end
+  end
+
+  context 'with puppetlabs GITHUB_REPOSITORY_OWNER' do
+    let(:result) { run_matrix_from_metadata_v3 }
+    let(:github_repository_owner) { 'puppetlabs' }
+
+    let(:matrix) do
+      [
+        'matrix={',
+        '"platforms":[',
+        '{"label":"AmazonLinux-2","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2","runner":"ubuntu-20.04"},',
+        '{"label":"AmazonLinux-2023","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2023","runner":"ubuntu-20.04"},',
+        '{"label":"RedHat-8","provider":"provision_service","arch":"x86_64","image":"rhel-8","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9","provider":"provision_service","arch":"x86_64","image":"rhel-9","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9-arm","provider":"provision_service","arch":"arm","image":"rhel-9-arm64","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-18.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:18.04","runner":"ubuntu-20.04"},',
+        '{"label":"Ubuntu-22.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:22.04","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-22.04-arm","provider":"provision_service","arch":"arm","image":"ubuntu-2204-lts-arm64","runner":"ubuntu-latest"}',
+        '],',
+        '"collection":[',
+        '"puppet7-nightly","puppet8-nightly"',
+        ']',
+        '}'
+      ].join
+    end
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix' do
+      expect(result.stdout).to include(
+        '::warning::CentOS-6 no provisioner found',
+        '::warning::Ubuntu-14.04 no provisioner found',
+        '::group::matrix',
+        '::group::spec_matrix'
+      )
+      expect(github_output_content).to include(matrix)
+      expect(github_output_content).to include(
+        'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
+      )
+    end
+  end
+
+  context 'with argument --puppetlabs' do
+    let(:result) { run_matrix_from_metadata_v3(['--puppetlabs']) }
+    let(:matrix) do
+      [
+        'matrix={',
+        '"platforms":[',
+        '{"label":"AmazonLinux-2","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2","runner":"ubuntu-20.04"},',
+        '{"label":"AmazonLinux-2023","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2023","runner":"ubuntu-20.04"},',
+        '{"label":"RedHat-8","provider":"provision_service","arch":"x86_64","image":"rhel-8","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9","provider":"provision_service","arch":"x86_64","image":"rhel-9","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9-arm","provider":"provision_service","arch":"arm","image":"rhel-9-arm64","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-18.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:18.04","runner":"ubuntu-20.04"},',
+        '{"label":"Ubuntu-22.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:22.04","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-22.04-arm","provider":"provision_service","arch":"arm","image":"ubuntu-2204-lts-arm64","runner":"ubuntu-latest"}',
+        '],',
+        '"collection":[',
+        '"puppet7-nightly","puppet8-nightly"',
+        ']',
+        '}'
+      ].join
+    end
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix' do
+      expect(result.stdout).to include(
+        '::warning::CentOS-6 no provisioner found',
+        '::warning::Ubuntu-14.04 no provisioner found',
+        '::group::matrix',
+        '::group::spec_matrix'
+      )
+      expect(github_output_content).to include(matrix)
+      expect(github_output_content).to include(
+        'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
+      )
+    end
+  end
+
+  context 'with --exclude-platforms "ubuntu-18.04"' do
+    let(:result) { run_matrix_from_metadata_v3(['--puppetlabs', '--platform-exclude', 'ubuntu-18.04']) }
+    let(:matrix) do
+      [
+        'matrix={',
+        '"platforms":[',
+        '{"label":"AmazonLinux-2","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2","runner":"ubuntu-20.04"},',
+        '{"label":"AmazonLinux-2023","provider":"docker","arch":"x86_64","image":"litmusimage/amazonlinux:2023","runner":"ubuntu-20.04"},',
+        '{"label":"RedHat-8","provider":"provision_service","arch":"x86_64","image":"rhel-8","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9","provider":"provision_service","arch":"x86_64","image":"rhel-9","runner":"ubuntu-latest"},',
+        '{"label":"RedHat-9-arm","provider":"provision_service","arch":"arm","image":"rhel-9-arm64","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-22.04","provider":"docker","arch":"x86_64","image":"litmusimage/ubuntu:22.04","runner":"ubuntu-latest"},',
+        '{"label":"Ubuntu-22.04-arm","provider":"provision_service","arch":"arm","image":"ubuntu-2204-lts-arm64","runner":"ubuntu-latest"}',
+        '],',
+        '"collection":[',
+        '"puppet7-nightly","puppet8-nightly"',
+        ']',
+        '}'
+      ].join
+    end
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix without excluded platforms' do
+      expect(result.stdout).to include(
+        '::warning::CentOS-6 no provisioner found',
+        '::warning::Ubuntu-14.04 no provisioner found',
+        '::notice::platform-exclude filtered Ubuntu-18.04',
+        '::group::matrix',
+        '::group::spec_matrix'
+      )
+      expect(github_output_content).to include(matrix)
+      expect(github_output_content).to include(
+        'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
+      )
+    end
+  end
+
+  context 'with --platform-exclude "ubuntu-(18.04|22.04)" --platform-exclude "redhat-[89]"' do
+    let(:result) { run_matrix_from_metadata_v3(['--puppetlabs', '--platform-exclude', '(amazonlinux|ubuntu)-(2|18.04|22.04|2023)', '--platform-exclude', 'redhat-[89]']) }
+    let(:matrix) do
+      [
+        'matrix={',
+        '"platforms":[',
+        '],',
+        '"collection":[',
+        '"puppet7-nightly","puppet8-nightly"',
+        ']',
+        '}'
+      ].join
+    end
+
+    it 'run successfully' do
+      expect(result.status_code).to eq 0
+    end
+
+    it 'generates the matrix without excluded platforms' do
+      expect(result.stdout).to include(
+        '::warning::CentOS-6 no provisioner found',
+        '::warning::Ubuntu-14.04 no provisioner found',
+        '::notice::platform-exclude filtered RedHat-8',
+        '::notice::platform-exclude filtered RedHat-9',
+        '::notice::platform-exclude filtered Ubuntu-18.04',
+        '::notice::platform-exclude filtered Ubuntu-22.04',
+        '::group::matrix',
+        '::group::spec_matrix'
+      )
+      expect(github_output_content).to include(matrix)
+      expect(github_output_content).to include(
+        'spec_matrix={"include":[{"puppet_version":"~> 7.24","ruby_version":2.7},{"puppet_version":"~> 8.0","ruby_version":3.2}]}'
+      )
+    end
+  end
+end

data/spec/lib/puppet_litmus/rake_helper_spec.rb

@@ -24,6 +24,9 @@ RSpec.shared_examples 'supported provisioner' do |args|
 end
 
 RSpec.describe PuppetLitmus::RakeHelper do
+  inventory_file = File.join(Dir.pwd, 'spec', 'fixtures', 'litmus_inventory.yaml')
+  let(:inventory_file) { inventory_file }
+
   context 'with provision_list' do
     let(:provision_hash) { { 'default' => { 'provisioner' => 'docker', 'images' => ['waffleimage/centos7'] } } }
     let(:results) { [] }
@@ -42,7 +45,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
         inventory_vars: nil,
         provision_hash: { 'default' => { 'provisioner' => 'docker', 'images' => ['waffleimage/centos7'] } },
         results: [],
-        params: { 'action' => 'provision', 'platform' => 'waffleimage/centos7', 'inventory' => Dir.pwd }
+        params: { 'action' => 'provision', 'platform' => 'waffleimage/centos7', 'inventory' => inventory_file }
       },
       {
         provisioner: 'vagrant',
@@ -50,7 +53,15 @@ RSpec.describe PuppetLitmus::RakeHelper do
         inventory_vars: nil,
         provision_hash: { 'default' => { 'provisioner' => 'vagrant', 'images' => ['centos7'] } },
         results: [],
-        params: { 'action' => 'provision', 'platform' => 'centos7', 'inventory' => Dir.pwd }
+        params: { 'action' => 'provision', 'platform' => 'centos7', 'inventory' => inventory_file }
+      },
+      {
+        provisioner: 'lxd',
+        platform: 'images:centos/7',
+        inventory_vars: nil,
+        provision_hash: { 'default' => { 'provisioner' => 'lxd', 'images' => ['images:centos/7'] } },
+        results: [],
+        params: { 'action' => 'provision', 'platform' => 'images:centos/7', 'inventory' => inventory_file }
       }
     ].freeze
 
@@ -68,7 +79,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
           [{ 'uri' => 'some.host', 'facts' => { 'provisioner' => 'docker', 'container_name' => 'foo', 'platform' => 'some.host' } }] }] }
     end
     let(:targets) { ['some.host'] }
-    let(:params) { { 'action' => 'tear_down', 'node_name' => 'some.host', 'inventory' => Dir.pwd } }
+    let(:params) { { 'action' => 'tear_down', 'node_name' => 'some.host', 'inventory' => inventory_file } }
 
     it 'calls function' do
       allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
@@ -89,7 +100,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
           ] }] }
     end
     let(:targets) { ['one.host'] }
-    let(:params) { { 'action' => 'tear_down', 'node_name' => 'one.host', 'inventory' => Dir.pwd } }
+    let(:params) { { 'action' => 'tear_down', 'node_name' => 'one.host', 'inventory' => inventory_file } }
 
     it 'calls function' do
       allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)

data/spec/lib/puppet_litmus/rake_tasks_spec.rb

@@ -22,10 +22,60 @@ describe 'litmus rake tasks' do
       expect($stdout).to receive(:puts).with('redhat-5-x86_64')
       expect($stdout).to receive(:puts).with('ubuntu-1404-x86_64')
       expect($stdout).to receive(:puts).with('ubuntu-1804-x86_64')
+      allow_any_instance_of(Object).to receive(:exit)
       Rake::Task['litmus:metadata'].invoke
     end
   end
 
+  context 'with litmus:install_module' do
+    let(:args) { { target_node_name: nil, module_repository: nil } }
+    let(:inventory_hash) { { 'groups' => [{ 'name' => 'ssh_nodes', 'nodes' => [{ 'uri' => 'some.host' }, { 'uri' => 'some.otherhost' }] }] } }
+    let(:target_nodes) { ['some.host', 'some.otherhost'] }
+    let(:dummy_tar) { 'spec/data/doot.tar.gz' }
+
+    before do
+      Rake::Task['litmus:install_module'].reenable
+      allow_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+      allow_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:find_targets).with(inventory_hash, args[:target_node_name]).and_return(target_nodes)
+    end
+
+    it 'installs module' do
+      expect_any_instance_of(Object).to receive(:build_module).and_return(dummy_tar)
+      expect($stdout).to receive(:puts).with("Built '#{dummy_tar}'")
+
+      expect_any_instance_of(Object).to receive(:install_module).with(inventory_hash, target_nodes, dummy_tar, args[:module_repository])
+      expect($stdout).to receive(:puts).with("Installed '#{dummy_tar}' on #{target_nodes.join(', ')}")
+      allow_any_instance_of(Object).to receive(:exit)
+      Rake::Task['litmus:install_module'].invoke(*args.values)
+    end
+
+    context 'with unknown target' do
+      let(:args) { { target_node_name: 'un.known', module_repository: nil } }
+      let(:target_nodes) { [] }
+
+      it 'exits with No targets found' do
+        expect do
+          expect($stdout).to receive(:puts).with('No targets found')
+          Rake::Task['litmus:install_module'].invoke(*args.values)
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq(0)
+        }
+      end
+    end
+
+    context 'when build_module returns nil' do
+      let(:dummy_tar) { nil }
+
+      it 'raises error if build fails' do
+        expect_any_instance_of(Object).to receive(:build_module).and_return(dummy_tar)
+        expect($stdout).to receive(:puts).with("Built '#{dummy_tar}'")
+
+        expect { Rake::Task['litmus:install_module'].invoke(*args.values) }
+          .to raise_error(RuntimeError, "Unable to find package in 'pkg/*.tar.gz'")
+      end
+    end
+  end
+
   context 'with litmus:install_modules_from_directory' do
     let(:inventory_hash) { { 'groups' => [{ 'name' => 'ssh_nodes', 'nodes' => [{ 'uri' => 'some.host' }] }] } }
     let(:target_dir) { File.join(Dir.pwd, 'spec/fixtures/modules') }
@@ -44,6 +94,7 @@ describe 'litmus rake tasks' do
       expect($stdout).to receive(:puts).with(start_with('Installing \'spec/data/doot.tar.gz\''))
       expect_any_instance_of(Object).to receive(:run_command).twice.and_return([])
       expect($stdout).to receive(:puts).with(start_with('Installed \'spec/data/doot.tar.gz\''))
+      allow_any_instance_of(Object).to receive(:exit)
       Rake::Task['litmus:install_modules_from_directory'].invoke('./spec/fixtures/modules')
     end
   end
@@ -54,6 +105,7 @@ describe 'litmus rake tasks' do
       expect(Rake::Task['litmus:provision_list']).to receive(:invoke).with('default')
       expect(Rake::Task['litmus:install_agent']).to receive(:invoke).with('puppet6')
       expect(Rake::Task['litmus:install_module']).to receive(:invoke)
+      allow_any_instance_of(Object).to receive(:exit)
       Rake::Task['litmus:provision_install'].invoke('default', 'puppet6')
     end
   end
@@ -77,7 +129,7 @@ describe 'litmus rake tasks' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with(any_args).and_return(results)
       allow_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).with(any_args).and_return({})
       allow_any_instance_of(PuppetLitmus::RakeHelper).to receive(:check_connectivity?).with(any_args).and_return(true)
-
+      allow_any_instance_of(Object).to receive(:exit)
       expect { Rake::Task['litmus:provision'].invoke('docker', 'centos:7') }.to output(/#{expected_output}/).to_stdout
     end
   end
@@ -89,6 +141,7 @@ describe 'litmus rake tasks' do
     it 'no key in provision file' do
       allow(File).to receive(:file?).with(any_args).and_return(true)
       expect(YAML).to receive(:load_file).with(provision_file).and_return(provision_hash)
+      allow_any_instance_of(Object).to receive(:exit)
       expect { Rake::Task['litmus:provision_list'].invoke('deet') }.to raise_error(/deet/)
     end
   end
@@ -100,6 +153,7 @@ describe 'litmus rake tasks' do
       stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
       expect_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
       expect_any_instance_of(PuppetLitmus::RakeHelper).to receive(:check_connectivity?).with(inventory_hash, nil).and_return(true)
+      allow_any_instance_of(Object).to receive(:exit)
       Rake::Task['litmus:check_connectivity'].invoke
     end
   end
@@ -108,6 +162,7 @@ describe 'litmus rake tasks' do
     it 'calls spec_prep' do
       expect(Rake::Task['spec_prep']).to receive(:invoke).and_return('')
       expect_any_instance_of(RSpec::Core::RakeTask).to receive(:run_task)
+      allow_any_instance_of(Object).to receive(:exit)
       Rake::Task['litmus:acceptance:localhost'].invoke
     end
   end

data/spec/lib/puppet_litmus/util_spec.rb

@@ -5,11 +5,12 @@ load File.expand_path('../../../lib/puppet_litmus/util.rb', __dir__)
 
 RSpec.describe PuppetLitmus::Util do
   context 'when using interpolate_powershell' do
+    let(:command) { 'foo' }
+    let(:encoded) { Base64.strict_encode64(command.encode('UTF-16LE')) }
+
     it 'interpolates the command' do
-      expect(described_class.interpolate_powershell('foo')).to match(/powershell\.exe/)
-      expect(described_class.interpolate_powershell('foo')).to match(/NoProfile/)
-      expect(described_class.interpolate_powershell('foo')).to match(/EncodedCommand/)
-      expect(described_class.interpolate_powershell('foo')).not_to match(/foo/)
+      expect(described_class.interpolate_powershell(command)).to eql("powershell.exe -NoProfile -EncodedCommand #{encoded}")
+      expect(described_class.interpolate_powershell(command)).not_to match(/#{command}/)
     end
   end
 end

data/spec/spec_helper.rb

@@ -5,32 +5,25 @@ require 'open3'
 require 'ostruct'
 
 if ENV['COVERAGE'] == 'yes'
-  require 'simplecov'
-
-  if ENV['CI'] == 'true'
-    require 'codecov'
-    SimpleCov.formatter = SimpleCov::Formatter::Codecov
-  else
+  begin
+    require 'simplecov'
+    require 'simplecov-console'
     SimpleCov.formatters = [
-      SimpleCov::Formatter::HTMLFormatter
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console
     ]
-  end
-  SimpleCov.start do
-    track_files 'lib/**/*.rb'
-
-    add_filter '/spec'
 
-    # do not track vendored files
-    add_filter '/vendor'
-    add_filter '/.vendor'
+    SimpleCov.start do
+      track_files 'lib/**/*.rb'
 
-    # do not track gitignored files
-    # this adds about 4 seconds to the coverage check
-    # this could definitely be optimized
-    add_filter do |f|
-      # system returns true if exit status is 0, which with git-check-ignore means file is ignored
-      system("git check-ignore --quiet #{f.filename}")
+      add_filter '/spec'
+      add_filter 'lib/puppet_litmus/version.rb'
+      # do not track vendored files
+      add_filter '/vendor'
+      add_filter '/.vendor'
     end
+  rescue LoadError
+    raise 'Add the simplecov & simplecov-console gems to Gemfile to enable this task'
   end
 end
 
@@ -45,6 +38,21 @@ def run_matrix_from_metadata_v2(options = {})
   )
 end
 
+def run_matrix_from_metadata_v3(options = [])
+  command = %w[bundle exec ./exe/matrix_from_metadata_v3]
+  unless options.include? '--metadata'
+    options << '--metadata'
+    options << File.join(File.dirname(__FILE__), 'exe', 'fake_metadata.json')
+  end
+  command += options
+  result = Open3.capture3(*command)
+  OpenStruct.new(
+    stdout: result[0],
+    stderr: result[1],
+    status_code: result[2]
+  )
+end
+
 # This is basically how `configure!` sets up RSpec in tests.
 require 'puppet_litmus'
 RSpec.configure do |config|