puppet_litmus 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b28ee9fd69e25bb7644899b004f8c188940bf2f8df398cbff9f849813e3b0b7
-  data.tar.gz: d6da95723ccd59175d110b07d6a2244733f1e85e26ed4d075fb8ada7c7e4888f
+  metadata.gz: fb5f589532820aa9325ab3653f0f02868f0127feb8d18c7b129c64c4358ce2c3
+  data.tar.gz: 66246c52058e285899fd523803dd32a0e097c7eef34c15e5f7a3b7525f1b2775
 SHA512:
-  metadata.gz: d34ca11e5202fb7fd3f365c7c2fcf975404f71e8581e9d46b550241132d3f90d40801d2db576041cd64ac64d2a95cbb4406b9ca9db910a5197159e594f0ae7fb
-  data.tar.gz: 5734185bbf729d032023d99bd25630fbe1d16e1c77e5c9875a6ca5d53ca9dd518a7f07616c8a48efe908191a1775ee1b730ef6f9eb7594826dd3ae622de5be7c
+  metadata.gz: 545df42c21e51cba530a74efd86d7275399190a1d3ebb5be20017eae10ac9d90ba71c92eb7c5a290dd5eed6221c955e83bcc539611d8bdcedda16d06ea61118c
+  data.tar.gz: fd36021b42b2d7ad2502c85394f767317f05561d37ab2bde05d38adf45d667cb045ea9c736b41518bd6dc5e54f48287069802a1e0253adebb6c4a0dbb77e36bc

data/README.md

@@ -18,13 +18,9 @@ Litmus is a command line tool that allows you to run acceptance tests against Pu
 Litmus allows you to:
 
 - Provision targets to test against
-
 - Install a Puppet agent
-
 - Install a module
-
 - Run tests
-
 - Tear down the infrastructure
 
 Litmus also facilitates parallel test runs and running tests in isolation. Each step is standalone, allowing other operations between test runs, such as debugging or configuration updates on the test targets.
@@ -33,33 +29,49 @@ Install Litmus as a gem by running `gem install puppet_litmus`.
 
 - Note if you choose to override the `litmus_inventory.yaml` location, please ensure that the directory structure you define exists.
 
-## matrix_from_metadata_v2
+## matrix_from_metadata_v3
 
-matrix_from_metadata_v2 tool generates a github action matrix from the supported operating systems listed in the module's metadata.json.
+matrix_from_metadata_v3 tool generates a github action matrix from the supported operating systems listed in the module's metadata.json.
 
 How to use it:
-in the project module root directory run `bundle exec matrix_from_metadata_v2`
-
-### --exclude-platforms parameter
-
-matrix_from_metadata_v2 accepts the `--exclude-platforms <JSON array>` argument in order to exclude some platforms from the matrix.
-
-For example:
-
-`$: bundle exec matrix_from_metadata_v2 --exclude-platforms '["debian-11","centos-8"]'`
-
-> Note: The option value should be JSON string otherwise it will throw an error.
-> The values provided in the json array are case-insensitive `["debian-11","centos-8"]'` or `["Debian-11","CentOS-8"]'` are treated as being the same.
-
-### --custom-matrix parameter
-
-matrix_from_metadata_v2 accepts the `--custom-matrix /path/to/matrix.json` argument in order to execute your test suite against a custom matrix. This is useful for use cases that do not fit the default matrix generated.
-
-In order to use this new functionality, run:
-
-`$: bundle exec matrix_from_metadata_v2 --custom-matrix matrix.json`
-
-> Note: The file should contain a valid Array of JSON Objects (i.e. see [here](https://github.com/puppetlabs/puppet_litmus/blob/main/docs/custom_matrix.json)), otherwise it will throw an error.
+in the project module root directory run `bundle exec matrix_from_metadata_v3`
+
+### Optional arguments
+
+| argument            | value | default           | description |
+|---------------------|-------|-------------------|-------------|
+| --matrix            | FILE  | built-in          | File containing possible collections and provisioners |
+| --metadata          | FILE  | metadata.json     | File containing module metadata json |
+| --debug             |       |                   | Enable debug messages |
+| --quiet             |       |                   | Disable notice messages |
+| --output            | TYPE  | auto              | Type of output to generate; auto, github or stdout |
+| --runner            | NAME  | ubuntu-latest     | Default Github action runner |
+| --puppet-include    | MAJOR |                   | Select puppet major version |
+| --puppet-exclude    | MAJOR |                   | Filter puppet major version |
+| --platform-include  | REGEX |                   | Select platform |
+| --platform-exclude  | REGEX |                   | Filter platform |
+| --arch-include      | REGEX |                   | Select architecture |
+| --arch-exclude      | REGEX |                   | Filter architecture |
+| --provision-prefer  | NAME  | docker            | Prefer provisioner |
+| --provision-include | NAME  | all               | Select provisioner |
+| --provision-exclude | NAME  | provision_service | Filter provisioner |
+
+> Refer to the [built-in matrix.json](https://github.com/puppetlabs/puppet_litmus/blob/main/exe/matrix.json) for a list of supported collection, provisioners, and platforms.
+
+### Examples
+
+* Only specific platforms
+  ```sh
+  matrix_from_metadata_v3 --platform-include redhat --platform-include 'ubuntu-(20|22).04'
+  ```
+* Exclude platforms
+  ```sh
+  matrix_from_metadata_v3 --platform-exclude redhat-7 --platform-exclude ubuntu-18.04
+  ```
+* Exclude architecture
+  ```sh
+  matrix_from_metadata_v3 --arch-exclude x86_64
+  ```
 
 ## Documentation
 

data/exe/matrix.json

@@ -0,0 +1,94 @@
+{
+    "collections": [
+        {
+            "puppet": 7.24,
+            "ruby": 2.7
+        },
+        {
+            "puppet": 8.0,
+            "ruby": 3.2
+        }
+    ],
+    "provisioners": {
+        "provision_service": {
+            "AlmaLinux": {
+                "8": { "x86_64": "almalinux-cloud/almalinux-8" },
+                "9": { "x86_64": "almalinux-cloud/almalinux-9" }
+            },
+            "CentOS": {
+                "7": { "x86_64": "centos-7" },
+                "8": { "x86_64": "centos-stream-8" },
+                "9": { "x86_64": "centos-stream-9" }
+            },
+            "Rocky": {
+                "8": { "x86_64": "rocky-linux-cloud/rocky-linux-8" },
+                "9": { "x86_64": "rocky-linux-cloud/rocky-linux-9" }
+            },
+            "Debian": {
+                "10": { "x86_64": "debian-10" },
+                "11": { "x86_64": "debian-11" },
+                "12": { "x86_64": "debian-12", "arm": "debian-12-arm64" }
+            },
+            "RedHat": {
+                "7": { "x86_64": "rhel-7" },
+                "8": { "x86_64": "rhel-8" },
+                "9": { "x86_64": "rhel-9", "arm": "rhel-9-arm64" }
+            },
+            "SLES" : {
+                "12":  { "x86_64": "sles-12" },
+                "15":  { "x86_64": "sles-15" }
+            },
+            "Ubuntu": {
+                "20.04": { "x86_64": "ubuntu-2004-lts" },
+                "22.04": { "x86_64": "ubuntu-2204-lts", "arm": "ubuntu-2204-lts-arm64" }
+            },
+            "Windows": {
+                "2016": { "x86_64": "windows-2016" },
+                "2019": { "x86_64": "windows-2019" },
+                "2022": { "x86_64": "windows-2022" }
+            }
+        },
+        "docker": {
+            "AmazonLinux": {
+                "2": { "x86_64": "litmusimage/amazonlinux:2" },
+                "2023": { "x86_64": "litmusimage/amazonlinux:2023" }
+            },
+            "CentOS": {
+                "7": { "x86_64": "litmusimage/centos:7" },
+                "8": { "x86_64": "litmusimage/centos:stream8" },
+                "9": { "x86_64": "litmusimage/centos:stream9" }
+            },
+            "Rocky": {
+                "8": { "x86_64": "litmusimage/rockylinux:8" },
+                "9": { "x86_64": "litmusimage/rockylinux:9" }
+            },
+            "AlmaLinux": {
+                "8": { "x86_64": "litmusimage/almalinux:8" },
+                "9": { "x86_64": "litmusimage/almalinux:9" }
+            },
+            "Debian": {
+                "10": { "x86_64": "litmusimage/debian:10" },
+                "11": { "x86_64": "litmusimage/debian:11" },
+                "12": { "x86_64": "litmusimage/debian:12" }
+            },
+            "OracleLinux": {
+                "7": { "x86_64": "litmusimage/oraclelinux:7" },
+                "8": { "x86_64": "litmusimage/oraclelinux:8" },
+                "9": { "x86_64": "litmusimage/oraclelinux:9" }
+            },
+            "Scientific": {
+                "7": { "x86_64": "litmusimage/scientificlinux:7" }
+            },
+            "Ubuntu": {
+                "18.04": { "x86_64": "litmusimage/ubuntu:18.04" },
+                "20.04": { "x86_64": "litmusimage/ubuntu:20.04" },
+                "22.04": { "x86_64": "litmusimage/ubuntu:22.04" }
+            }
+        }
+    },
+    "github_runner": {
+        "docker": {
+            "^(AmazonLinux-2|(CentOS|OracleLinux|Scientific)-7|Ubuntu-18|Debian-10)": "ubuntu-20.04"
+        }
+    }
+}

data/exe/matrix_from_metadata_v2

@@ -36,6 +36,7 @@ IMAGE_TABLE = {
 }.freeze
 
 ARM_IMAGE_TABLE = {
+  'Debian-12-arm' => 'debian-12-arm64',
   'RedHat-9-arm' => 'rhel-9-arm64',
   'Ubuntu-22.04-arm' => 'ubuntu-2204-lts-arm64'
 }.freeze
@@ -108,11 +109,15 @@ if ARGV.include?('--provision-service')
   # NOTE: that the below are the only available images for the provision service
   updated_platforms = {
     'AlmaLinux-8' => 'almalinux-cloud/almalinux-8',
+    'AlmaLinux-9' => 'almalinux-cloud/almalinux-9',
     'CentOS-7' => 'centos-7',
     'CentOS-8' => 'centos-stream-8',
+    'CentOS-9' => 'centos-stream-9',
     'Rocky-8' => 'rocky-linux-cloud/rocky-linux-8',
+    'Rocky-9' => 'rocky-linux-cloud/rocky-linux-9',
     'Debian-10' => 'debian-10',
     'Debian-11' => 'debian-11',
+    'Debian-12' => 'debian-12',
     'Ubuntu-20.04' => 'ubuntu-2004-lts',
     'Ubuntu-22.04' => 'ubuntu-2204-lts'
   }
@@ -123,6 +128,12 @@ if ARGV.include?('--provision-service')
   DOCKER_PLATFORMS = {}.freeze
 end
 
+# disable provision service if repository owner is not puppetlabs
+unless ['puppetlabs', nil].include?(ENV.fetch('GITHUB_REPOSITORY_OWNER', nil))
+  IMAGE_TABLE = {}.freeze
+  ARM_IMAGE_TABLE = {}.freeze
+end
+
 metadata_path = ENV['TEST_MATRIX_FROM_METADATA'] || 'metadata.json'
 metadata = JSON.parse(File.read(metadata_path))
 

data/exe/matrix_from_metadata_v3

@@ -0,0 +1,314 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'English'
+require 'json'
+require 'optparse'
+require 'ostruct'
+
+# wrap up running in a Github Action
+module Action
+  class << self
+    attr_reader :type
+
+    def init(to = 'auto')
+      @notice = true
+      @type = if to.eql? 'auto'
+                ENV['GITHUB_ACTIONS'] ? 'github' : 'stdout'
+              else
+                to
+              end
+      $stderr = $stdout if @type == 'github'
+    end
+
+    def config(**args)
+      error("invalid Action.config: #{args}") unless args.is_a?(Hash)
+      args.each do |arg|
+        instance_variable_set(:"@#{arg[0]}", arg[1])
+      end
+    end
+
+    def debug(msg = nil)
+      return @debug if msg.nil?
+
+      output(msg, '::debug::') if @debug
+    end
+
+    def notice(msg = nil)
+      return @notice if msg.nil?
+
+      output(msg, '::notice::') if @notice
+    end
+
+    def error(msg)
+      output(msg, '::error::')
+      exit 1
+    end
+
+    def warning(msg)
+      output(msg, '::warning::')
+    end
+
+    def group(name, data, **kwargs)
+      output(name, '::group::')
+      output(data, **kwargs)
+      output('', '::endgroup::') if @type == 'github'
+
+      self
+    end
+
+    def set_output(key, value)
+      @output ||= @type == 'github' ? ENV.fetch('GITHUB_OUTPUT', nil) : '/dev/stdout'
+
+      if @output.nil?
+        Action.warning('GITHUB_OUTPUT environment is not set, sending output to stdout')
+        @output = '/dev/stdout'
+      end
+
+      File.open(@output, 'a') { |f| f.puts "#{key}=#{JSON.generate(value)}" }
+
+      self
+    end
+
+    private
+
+    def output(msg, prefix = nil, pretty: false)
+      $stderr.print prefix if @type == 'github'
+      $stderr.puts pretty ? JSON.pretty_generate(msg) : msg.to_s
+
+      self
+    end
+  end
+end
+
+options = OpenStruct.new(
+  puppet_exclude: [],
+  puppet_include: [],
+  platform_exclude: [],
+  platform_include: [],
+  arch_include: [],
+  arch_exclude: [],
+  provision_prefer: [],
+  provision_include: [],
+  provision_exclude: []
+)
+
+default_options = {
+  'provision-prefer': 'docker',
+  runner: 'ubuntu-latest',
+  output: 'auto',
+  matrix: File.join(File.dirname(__FILE__), 'matrix.json'),
+  metadata: 'metadata.json'
+}
+
+begin
+  Action.init
+
+  # default disable provision_service if puppetlabs is not the owner
+  default_options[:'provision-exclude'] = 'provision_service' \
+    if ARGV.reject! { |x| x == '--puppetlabs' }.nil? && !['puppetlabs'].include?(ENV.fetch('GITHUB_REPOSITORY_OWNER', nil))
+
+  # apply default_options if not overridden on the command line
+  default_options.each do |arg, value|
+    ARGV.unshift("--#{arg}", value) unless ARGV.grep(/\A--#{arg}(=.*)?\z/).any?
+  end
+
+  OptionParser.accept(JSON) do |v|
+    begin
+      x = JSON.parse(File.read(v)) if v
+      raise "nothing parsed from file #{v}" if x.empty?
+
+      x
+    rescue JSON::ParserError
+      raise "error parsing file #{v}"
+    end
+  rescue RuntimeError, Errno::ENOENT
+    raise OptionParser::InvalidArgument, $ERROR_INFO unless ARGV.grep(/^-(h|help)$/).any?
+  end
+
+  OutputType = ->(value) {}
+  OptionParser.accept(OutputType) do |v|
+    raise OptionParser::InvalidArgument, v \
+      unless %w[auto github stdout].include?(v)
+
+    Action.init(v)
+  end
+
+  OptionParser.accept(Regexp) { |v| Regexp.new(v, Regexp::IGNORECASE) }
+
+  OptionParser.new do |opt|
+    opt.separator "Generate Github Actions Matrices from Puppet metadata.json\n\nOptions:"
+    opt.on('--matrix FILE', JSON, 'File containing possible collections and provisioners (default: built-in)') { |o| options.matrix = o }
+    opt.on('--metadata FILE', JSON, "File containing module metadata json (default: #{default_options[:metadata]})\n\n") { |o| options.metadata = o }
+
+    opt.on('--debug', TrueClass, 'Enable debug messages') { |o| options.debug = o }
+    opt.on('--quiet', TrueClass, 'Disable notice messages') { |o| options.quiet = o }
+    opt.on('--output TYPE', OutputType, "Type of output to generate; auto, github or stdout (default: #{default_options[:output]})\n\n") { |o| options.output = o }
+
+    opt.on('--runner NAME', String, "Default Github action runner (default: #{default_options[:runner]})") { |o| options.runner = o }
+
+    opt.on('--puppet-include MAJOR', Integer, 'Select puppet major version') { |o| options.puppet_include << o }
+    opt.on('--puppet-exclude MAJOR', Integer, 'Filter puppet major version') { |o| options.puppet_exclude << o }
+
+    opt.on('--platform-include REGEX', Regexp, 'Select platform') { |o| options.platform_include << o }
+    opt.on('--platform-exclude REGEX', Regexp, 'Filter platform') { |o| options.platform_exclude << o }
+
+    opt.on('--arch-include REGEX', Regexp, 'Select architecture') { |o| options.arch_include << o }
+    opt.on('--arch-exclude REGEX', Regexp, 'Filter architecture') { |o| options.arch_exclude << o }
+
+    opt.on('--provision-prefer NAME', String, "Prefer provisioner (default: #{default_options[:'provision-prefer']})") { |o| options.provision_prefer.push(*o.split(',')) }
+    opt.on('--provision-include NAME', String, 'Select provisioner (default: all)') { |o| options.provision_include.push(*o.split(',')) }
+    opt.on('--provision-exclude NAME', String, "Filter provisioner (default: #{default_options[:'provision-exclude'] || 'none'})") { |o| options.provision_exclude.push(*o.split(',')) }
+  end.parse!
+
+  Action.config(debug: true) if options[:debug]
+  Action.config(notice: false) if options[:quiet] && !options[:debug]
+
+  # validate provisioners
+  options[:provision_include].select! do |p|
+    options[:matrix]['provisioners'].key?(p) or raise OptionParser::InvalidArgument, "--provision-include '#{p}' not found in provisioners"
+  end
+
+  # filter provisioners
+  unless options[:provision_include].empty?
+    options[:matrix]['provisioners'].delete_if do |k, _|
+      unless options[:provision_include].include?(k.to_s)
+        Action.debug("provision-include filtered #{k}")
+        true
+      end
+    end
+  end
+  options[:matrix]['provisioners'].delete_if do |k, _|
+    if options[:provision_exclude].include?(k.to_s)
+      Action.debug("provision-exclude filtered #{k}")
+      true
+    end
+  end
+
+  # sort provisioners
+  options[:matrix]['provisioners'] = options[:matrix]['provisioners'].sort_by { |key, _| options[:provision_prefer].index(key.to_s) || options[:provision_prefer].length }.to_h \
+    unless options[:provision_prefer].empty?
+
+  # union regexp option values
+  %w[platform arch].each do |c|
+    [:"#{c}_exclude", :"#{c}_include"].each do |k|
+      options[k] = if options[k].empty?
+                     nil
+                   else
+                     Regexp.new(format('\A(?:%s)\z', Regexp.union(options[k])), Regexp::IGNORECASE)
+                   end
+    end
+  end
+
+  raise OptionParser::ParseError, 'no provisioners left after filters applied' if options[:matrix]['provisioners'].empty?
+rescue OptionParser::ParseError => e
+  Action.error(e)
+end
+
+matrix = { platforms: [], collection: [] }
+spec_matrix = { include: [] }
+
+# collection matrix
+version_re = /([>=<]{1,2})\s*([\d.]+)/
+options[:metadata]['requirements']&.each do |req|
+  next unless req['name'] == 'puppet' && req['version_requirement']
+
+  puppet_version_reqs = req['version_requirement'].scan(version_re).map(&:join)
+  if puppet_version_reqs.empty?
+    Action.warning("Didn't recognize version_requirement '#{req['version_requirement']}'")
+    break
+  end
+
+  options[:matrix]['collections'].each do |collection|
+    next unless options[:puppet_include].each do |major|
+      break if major != collection['puppet'].to_i
+
+      Action.debug("puppet-include matched collection #{collection.inspect}")
+    end
+
+    next unless options[:puppet_exclude].each do |major|
+      if major.eql? collection['puppet'].to_i
+        Action.debug("puppet-exclude matched collection #{collection.inspect}")
+        break
+      end
+    end
+
+    # Test against the "largest" puppet version in a collection, e.g. `7.9999` to allow puppet requirements with a non-zero lower bound on minor/patch versions.
+    # This assumes that such a boundary will always allow the latest actually existing puppet version of a release stream, trading off simplicity vs accuracy here.
+    gem_req = Gem::Requirement.create(puppet_version_reqs)
+    next unless gem_req.satisfied_by?(Gem::Version.new("#{collection['puppet'].to_i}.9999"))
+
+    matrix[:collection] << "puppet#{collection['puppet'].to_i}-nightly"
+
+    spec_matrix[:include] << {
+      puppet_version: "~> #{collection['puppet']}",
+      ruby_version: collection['ruby']
+    }
+  end
+end
+
+# Set platforms based on declared operating system support
+options[:metadata]['operatingsystem_support'].each do |os_sup|
+  os_sup['operatingsystemrelease'].sort_by(&:to_i).each do |os_ver|
+    os_ver_platforms = []
+    platform_key = [os_sup['operatingsystem'], os_ver]
+
+    # filter platforms
+    if options[:platform_include] && platform_key[0].match?(options[:platform_include]) == false && platform_key.join('-').match?(options[:platform_include]) == false
+      Action.notice("platform-include filtered #{platform_key.join('-')}")
+      next
+    end
+
+    if options[:platform_exclude] && (platform_key[0].match?(options[:platform_exclude]) || platform_key.join('-').match?(options[:platform_exclude]))
+      Action.notice("platform-exclude filtered #{platform_key.join('-')}")
+      next
+    end
+
+    options[:matrix]['provisioners'].each do |provisioner, platforms|
+      images = platforms.dig(*platform_key)
+      next if images.nil?
+
+      # filter arch
+      images.delete_if do |arch, _|
+        next if options[:arch_include]&.match?(arch.downcase) == true
+        next unless options[:arch_exclude]&.match?(arch.downcase)
+
+        Action.notice("arch filtered #{platform_key.join('-')}-#{arch} from #{provisioner}")
+      end
+      next if images.empty?
+
+      images.each do |arch, image|
+        label = (arch.eql?('x86_64') ? platform_key : platform_key + [arch]).join('-')
+        next if os_ver_platforms.any? { |h| h[:label] == label }
+
+        runner = options[:matrix]['github_runner'][provisioner]&.reduce(options[:runner]) do |memo, (reg, run)|
+          label.match?(/#{reg}/i) ? run : memo
+        end
+
+        os_ver_platforms << {
+          label: label,
+          provider: provisioner,
+          arch: arch,
+          image: image,
+          runner: runner.nil? ? options[:runner] : runner
+        }
+      end
+    end
+
+    if os_ver_platforms.empty?
+      Action.warning("#{platform_key.join('-')} no provisioner found")
+    else
+      matrix[:platforms].push(*os_ver_platforms)
+    end
+  end
+end
+
+Action.group('matrix', matrix, pretty: true).group('spec_matrix', spec_matrix, pretty: true) if Action.type == 'github' && Action.notice
+
+Action.error('no supported puppet versions') if matrix[:collection].empty?
+
+if Action.type == 'stdout'
+  $stdout.puts JSON.generate({ matrix: matrix, spec_matrix: spec_matrix })
+else
+  Action.set_output('matrix', matrix).set_output('spec_matrix', spec_matrix)
+end

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -10,11 +10,7 @@ module PuppetLitmus::InventoryManipulation
   # @return [Hash] hash of the litmus_inventory.yaml file.
   def inventory_hash_from_inventory_file(inventory_full_path = nil)
     require 'yaml'
-    inventory_full_path = if inventory_full_path.nil?
-                            "#{Dir.pwd}/spec/fixtures/litmus_inventory.yaml"
-                          else
-                            inventory_full_path
-                          end
+    inventory_full_path = "#{Dir.pwd}/spec/fixtures/litmus_inventory.yaml" if inventory_full_path.nil?
     raise "There is no inventory file at '#{inventory_full_path}'." unless File.exist?(inventory_full_path)
 
     YAML.load_file(inventory_full_path)
@@ -103,7 +99,7 @@ module PuppetLitmus::InventoryManipulation
     output_collector = []
     targets_in_inventory(inventory) do |target|
       vars = target['vars']
-      roles = [(vars['role'] || vars['roles'])].flatten
+      roles = [vars['role'] || vars['roles']].flatten
       roles = roles.map(&:downcase)
       output_collector << target['uri'] if roles.include? role.downcase
     end

data/lib/puppet_litmus/rake_helper.rb

@@ -7,7 +7,7 @@ require 'puppet_litmus/version'
 module PuppetLitmus::RakeHelper
   # DEFAULT_CONFIG_DATA should be frozen for our safety, but it needs to work around https://github.com/puppetlabs/bolt/pull/1696
   DEFAULT_CONFIG_DATA = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') } # .freeze # rubocop:disable Style/MutableConstant
-  SUPPORTED_PROVISIONERS = %w[abs docker docker_exp provision_service vagrant vmpooler].freeze
+  SUPPORTED_PROVISIONERS = %w[abs docker docker_exp lxd provision_service vagrant vmpooler].freeze
 
   # Gets a string representing the operating system and version.
   #
@@ -68,7 +68,7 @@ module PuppetLitmus::RakeHelper
     raise "the provision module was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" unless
       File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
 
-    params = { 'action' => 'provision', 'platform' => platform, 'inventory' => Dir.pwd }
+    params = { 'action' => 'provision', 'platform' => platform, 'inventory' => File.join(Dir.pwd, 'spec', 'fixtures', 'litmus_inventory.yaml') }
     params['vars'] = inventory_vars unless inventory_vars.nil?
 
     task_name = provisioner_task(provisioner)
@@ -83,12 +83,9 @@ module PuppetLitmus::RakeHelper
     inventory_vars = provision_hash[key]['vars']
     # Splat the params into environment variables to pass to the provision task but only in this runspace
     provision_hash[key]['params']&.each { |k, value| ENV[k.upcase] = value.to_s }
-    results = []
-
-    provision_hash[key]['images'].each do |image|
-      results << provision(provisioner, image, inventory_vars)
+    provision_hash[key]['images'].map do |image|
+      provision(provisioner, image, inventory_vars)
     end
-    results
   end
 
   def tear_down_nodes(targets, inventory_hash)
@@ -123,7 +120,7 @@ module PuppetLitmus::RakeHelper
     # how do we know what provisioner to use
     add_platform_field(inventory_hash, node_name)
 
-    params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
+    params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => File.join(Dir.pwd, 'spec', 'fixtures', 'litmus_inventory.yaml') }
     node_facts = facts_from_node(inventory_hash, node_name)
     bolt_result = run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
     raise_bolt_errors(bolt_result, "tear_down of #{node_name} failed.")
@@ -160,11 +157,11 @@ module PuppetLitmus::RakeHelper
   def configure_path(inventory_hash)
     results = []
     # fix the path on ssh_nodes
-    unless inventory_hash['groups'].select { |group| group['name'] == 'ssh_nodes' && !group['targets'].empty? }.empty?
+    unless inventory_hash['groups'].none? { |group| group['name'] == 'ssh_nodes' && !group['targets'].empty? }
       results << run_command('echo PATH="$PATH:/opt/puppetlabs/puppet/bin" > /etc/environment',
                              'ssh_nodes', config: nil, inventory: inventory_hash)
     end
-    unless inventory_hash['groups'].select { |group| group['name'] == 'winrm_nodes' && !group['targets'].empty? }.empty?
+    unless inventory_hash['groups'].none? { |group| group['name'] == 'winrm_nodes' && !group['targets'].empty? }
       results << run_command('[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Puppet Labs\Puppet\bin;C:\Program Files (x86)\Puppet Labs\Puppet\bin", "Machine")',
                              'winrm_nodes', config: nil, inventory: inventory_hash)
     end

data/lib/puppet_litmus/spec_helper_acceptance.rb

@@ -28,6 +28,12 @@ module PuppetLitmus
         host = ENV.fetch('TARGET_HOST', nil)
         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.4.0'
+  VERSION = '1.5.0'
 end

data/spec/exe/matrix_from_metadata_v2_spec.rb

@@ -125,4 +125,43 @@ RSpec.describe 'matrix_from_metadata_v2' do
       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/spec_helper.rb

@@ -38,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|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-01 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -125,15 +125,19 @@ description: "    Providing a simple command line tool for puppet content creato
 email:
 - info@puppet.com
 executables:
+- matrix.json
 - matrix_from_metadata
 - matrix_from_metadata_v2
+- matrix_from_metadata_v3
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- exe/matrix.json
 - exe/matrix_from_metadata
 - exe/matrix_from_metadata_v2
+- exe/matrix_from_metadata_v3
 - lib/puppet_litmus.rb
 - lib/puppet_litmus/inventory_manipulation.rb
 - lib/puppet_litmus/puppet_helpers.rb
@@ -147,6 +151,7 @@ files:
 - spec/data/jim.yaml
 - spec/exe/fake_metadata.json
 - spec/exe/matrix_from_metadata_v2_spec.rb
+- spec/exe/matrix_from_metadata_v3_spec.rb
 - spec/lib/puppet_litmus/inventory_manipulation_spec.rb
 - spec/lib/puppet_litmus/puppet_helpers_spec.rb
 - spec/lib/puppet_litmus/puppet_litmus_version_spec.rb