puppet_litmus 0.27.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d77bde09896757aa35ff61163febb315e2d50682b1b2dcdfdbc53b77da576c8
-  data.tar.gz: d80089f753244e77bf491e4bc9ac14a42e6ae112a85d4b6f41206c38b22b7a07
+  metadata.gz: 80914970290db5501971ee324794c82101f204d1c78a74cbd618547f8fb345c0
+  data.tar.gz: 596c114a8c75fb36f6ab8350850eca9005036fbdf12ed7d3465e2375c937579e
 SHA512:
-  metadata.gz: 31a2ac1b11fb651d06de17648e345fbab6105ceb92ff9da52632bba725f1689a111219040e5dacf25cc775382ea15c3845167318a45a953cfb33ab1ebf509d30
-  data.tar.gz: 108b085470b7d07a438c105871300f9a5a759443592073239c4c4d9c8648207c51774c9689a951ef3adc4b70796cada4f47b4f3263c295fde5aafa99f41ac472
+  metadata.gz: eef1f207558172836438bc1bb5686610af52560bd7eb99ae2ff9ae332fa3705f249587dd4eb4f12c4ffd83c0011d03764dd6fa974b21be4012144829d984a429
+  data.tar.gz: 57d962b1ea4e49fd483319514197f5b1d119ab9b69e981c2e3a17f151b71358477b6a7276bbee3101f3d0a5f1d00a0cb081de953dfbf750e1ba6d53016836f58

data/README.md

@@ -12,17 +12,39 @@
 Litmus is a command line tool that allows you to run acceptance tests against Puppet modules.
 
 Litmus allows you to:
-* Provision targets to test against
-* Install a Puppet agent
-* Install a module
-* Run tests
-* Tear down the infrastructure
+
+- 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.
 
-Install Litmus as a gem by running ```gem install puppet_litmus```.
+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 strutcture you define exists.
+
+## matrix_from_metadata_v2
+
+matrix_from_metadata_v2 tool generates github actions matrix from 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 `--exclude-platforms <JSON array>` option in order to exclude some platforms from GA matrixes.
+
+In order to use this new functionality just simply run:
+
+`$: bundle exec matrix_from_metadata_v2 --exclude-platforms '["debian-11","centos-8"]'`
 
-* Note if you choose to override the `litmus_inventory.yaml` location, please ensure that the directory strutcture you define exists.
+> 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.
 
 ## Documentation
 
@@ -30,4 +52,4 @@ For documentation, see our [Litmus Docs Site](https://puppetlabs.github.io/litmu
 
 ## Other Resources
 
-* [Is it Worth the Time?](https://xkcd.com/1205/)
+- [Is it Worth the Time?](https://xkcd.com/1205/)

data/exe/matrix_from_metadata_v2

@@ -13,15 +13,19 @@ IMAGE_TABLE = {
   'Windows-2012 R2' => 'windows-2012-r2-core',
   'Windows-2016' => 'windows-2016',
   'Windows-2019' => 'windows-2019-core',
+  'Windows-2022' => 'windows-2022',
 }.freeze
 
 DOCKER_PLATFORMS = {
   'CentOS-6' => 'litmusimage/centos:6',
   'CentOS-7' => 'litmusimage/centos:7',
   'CentOS-8' => 'litmusimage/centos:8',
-  'Debian-10' => 'litmusimage/debian:10',
+  'Rocky-8' => 'litmusimage/rockylinux:8',
+  'AlmaLinux-8' => 'litmusimage/almalinux:8',
   # 'Debian-8' => 'litmusimage/debian:8', Removing from testing: https://puppet.com/docs/pe/2021.0/supported_operating_systems.html
   'Debian-9' => 'litmusimage/debian:9',
+  'Debian-10' => 'litmusimage/debian:10',
+  'Debian-11' => 'litmusimage/debian:11',
   'OracleLinux-6' => 'litmusimage/oraclelinux:6',
   'OracleLinux-7' => 'litmusimage/oraclelinux:7',
   'Scientific-6' => 'litmusimage/scientificlinux:6',
@@ -54,26 +58,45 @@ spec_matrix = {
   include: [],
 }
 
-metadata = JSON.parse(File.read('metadata.json'))
+if ARGV.include?('--exclude-platforms')
+  exclude_platforms_occurencies = ARGV.select { |arg| arg == '--exclude-platforms' }.length
+  raise '--exclude-platforms argument should be present just one time in the command' unless exclude_platforms_occurencies <= 1
+
+  exclude_platforms_list = ARGV[ARGV.find_index('--exclude-platforms') + 1]
+  raise 'you need to provide a list of platforms in JSON format' if exclude_platforms_list.nil?
+
+  begin
+    exclude_list = JSON.parse(exclude_platforms_list).map { |platform| platform.downcase }
+  rescue JSON::ParserError
+    raise 'the exclude platforms list must valid JSON'
+  end
+else
+  exclude_list = []
+end
+
+metadata_path = ENV['TEST_MATRIX_FROM_METADATA'] || 'metadata.json'
+metadata = JSON.parse(File.read(metadata_path))
 # Set platforms based on declared operating system support
 metadata['operatingsystem_support'].sort_by { |a| a['operatingsystem'] }.each do |sup|
   os = sup['operatingsystem']
   sup['operatingsystemrelease'].sort_by { |a| a.to_i }.each do |ver|
     image_key = "#{os}-#{ver}"
-    if IMAGE_TABLE.key? image_key
+
+    if IMAGE_TABLE.key?(image_key) && !exclude_list.include?(image_key.downcase)
       matrix[:platforms] << {
         label: image_key,
         provider: 'provision::provision_service',
         image: IMAGE_TABLE[image_key],
       }
-    elsif DOCKER_PLATFORMS.key? image_key
+    elsif DOCKER_PLATFORMS.key?(image_key) && !exclude_list.include?(image_key.downcase)
       matrix[:platforms] << {
         label: image_key,
         provider: 'provision::docker',
         image: DOCKER_PLATFORMS[image_key],
       }
     else
-      puts "::warning::Cannot find image for #{image_key}"
+      puts "::warning::#{image_key} was excluded from testing" if exclude_list.include?(image_key.downcase)
+      puts "::warning::Cannot find image for #{image_key}" unless exclude_list.include?(image_key.downcase)
     end
   end
 end

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -6,8 +6,8 @@ module PuppetLitmus; end # rubocop:disable Style/Documentation
 module PuppetLitmus::InventoryManipulation
   # Creates an inventory hash from the inventory.yaml.
   #
-  # @param inventory_full_path [String] path to the inventory.yaml file
-  # @return [Hash] hash of the inventory.yaml file.
+  # @param inventory_full_path [String] path to the litmus_inventory.yaml file
+  # @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?
@@ -53,6 +53,85 @@ module PuppetLitmus::InventoryManipulation
     end
   end
 
+  # Recursively find and iterate over the groups in an inventory. If no block is passed
+  # to the function then only the name of the group is returned. If a block is passed
+  # then the block is executed against each group and the value of the block is returned.
+  #
+  # @param inventory_hash [Hash] Inventory hash from inventory.yaml
+  # @param block [Block] Block to execute against each node
+  def groups_in_inventory(inventory_hash, &block)
+    inventory_hash['groups'].flat_map do |group|
+      output_collector = []
+      output_collector << if block_given?
+                            yield group
+                          else
+                            group['name'].downcase
+                          end
+      output_collector << groups_in_inventory({ 'groups' => group['groups'] }, &block) if group.key? 'groups'
+      output_collector.flatten.compact
+    end
+  end
+
+  # Iterate over all targets in an inventory. If no block is given to the function
+  # it will return the name of every target in the inventory. If a block is passed
+  # it will execute the block on each target and return the value of the block.
+  #
+  # @param inventory_hash [Hash] Inventory hash from inventory.yaml
+  # @param block [Block] Block to execute against each node
+  def targets_in_inventory(inventory_hash)
+    groups_in_inventory(inventory_hash) do |group|
+      if group.key? 'targets'
+        group['targets'].map do |target|
+          if block_given?
+            (yield target)
+          else
+            target['uri'].downcase
+          end
+        end
+      end
+    end
+  end
+
+  # Find all targets in an inventory that have a role. The roles for a target are
+  # specified in the vars hash for a target. This function is tolerant to the roles
+  # hash being called either 'role' or 'roles' and it is tolerant to the roles being
+  # either a single key value or an array of roles.
+  #
+  # @param role [String] The name of a role to search for
+  # @param inventory [Hash] Inventory hash from inventory.yaml
+  def nodes_with_role(role, inventory)
+    output_collector = []
+    targets_in_inventory(inventory) do |target|
+      vars = target['vars']
+      roles = [(vars['role'] || vars['roles'])].flatten
+      roles = roles.map { |r| r.downcase }
+      output_collector << target['uri'] if roles.include? role.downcase
+    end
+    output_collector unless output_collector.empty?
+  end
+
+  # Searches through the inventory hash to either validate that a group being targeted exists,
+  # validate that a specific target being targeted exists, or resolves role names to a
+  # list of nodes to target. Targets and roles can be specified as strings or as symbols, and
+  # the functions are tolerant to incorrect capitalization.
+  #
+  # @param target [String] || [Array[String]] A list of targets
+  # @param inventory [Hash] inventory hash from inventory.yaml
+  def search_for_target(target, inventory)
+    result_collector = []
+    groups = groups_in_inventory(inventory)
+    Array(target).map do |name|
+      result_collector << name if groups.include? name.to_s.downcase
+      result_collector << name if targets_in_inventory(inventory).include? name.to_s.downcase
+      result_collector << nodes_with_role(name.to_s, inventory)
+    end
+
+    result_collector = result_collector.flatten.compact
+    raise 'targets not found in inventory' if result_collector.empty?
+
+    result_collector
+  end
+
   # Determines if a node_name exists in a group in the inventory_hash.
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
@@ -86,14 +165,13 @@ module PuppetLitmus::InventoryManipulation
   # @param node_name [String] node to locate in the group
   # @return [Hash] config for node of name node_name
   def config_from_node(inventory_hash, node_name)
-    inventory_hash['groups'].each do |group|
-      group['targets'].each do |node|
-        if node['uri'] == node_name
-          return node['config']
-        end
-      end
+    config = targets_in_inventory(inventory_hash) do |target|
+      next unless target['uri'].downcase == node_name.downcase
+
+      return target['config'] unless target['config'].nil?
     end
-    raise "No config was found for #{node_name}"
+
+    config.empty? ? nil : config[0]
   end
 
   # Finds a facts hash in the inventory hash by searching for a node name.
@@ -102,14 +180,13 @@ module PuppetLitmus::InventoryManipulation
   # @param node_name [String] node to locate in the group
   # @return [Hash] facts for node of name node_name
   def facts_from_node(inventory_hash, node_name)
-    inventory_hash['groups'].each do |group|
-      group['targets'].each do |node|
-        if node['uri'] == node_name
-          return node['facts']
-        end
-      end
+    facts = targets_in_inventory(inventory_hash) do |target|
+      next unless target['uri'].downcase == node_name.downcase
+
+      target['facts'] unless target['facts'].nil?
     end
-    raise "No facts were found for #{node_name}"
+
+    facts.empty? ? nil : facts[0]
   end
 
   # Finds a var hash in the inventory hash by searching for a node name.
@@ -118,14 +195,12 @@ module PuppetLitmus::InventoryManipulation
   # @param node_name [String] node to locate in the group
   # @return [Hash] vars for node of name node_name
   def vars_from_node(inventory_hash, node_name)
-    inventory_hash['groups'].each do |group|
-      group['targets'].each do |node|
-        if node['uri'] == node_name
-          return node['vars']
-        end
-      end
+    vars = targets_in_inventory(inventory_hash) do |target|
+      next unless target['uri'].downcase == node_name.downcase
+
+      target['vars'] unless target['vars'].nil?
     end
-    {}
+    vars.empty? ? {} : vars[0]
   end
 
   # Adds a node to a group specified, if group_name exists in inventory hash.
@@ -266,4 +341,27 @@ module PuppetLitmus::InventoryManipulation
     end
     Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
   end
+
+  # Add platform custom information field to the current span for each node being targeted.
+  # If more than one node is being targeted, each node will be given a separate custom field.
+  #
+  # @param span [Honeycomb::Span] The current span
+  # @param target_node_names [Array[String]] Nodes being targeted
+  # @param inventory_hash [Hash] Hash of the inventory.yaml file
+  def add_node_fields_to_span(span, target_node_names, inventory_hash)
+    node_counter = 1
+    Array(target_node_names).each do |target_name|
+      name_field     = 'litmus.node_name'
+      platform_field = 'litmus.platform'
+
+      name_field = "#{name_field}_#{node_counter}"
+      platform_field = "#{platform_field}_#{node_counter}"
+      span.add_field(name_field, target_name)
+      if target_in_inventory?(inventory_hash, target_name)
+        facts = facts_from_node(inventory_hash, target_name)
+        span.add_field(platform_field, facts&.dig('platform')) unless facts.nil?
+      end
+      node_counter += 1
+    end
+  end
 end

data/lib/puppet_litmus/puppet_helpers.rb

@@ -6,13 +6,24 @@ module PuppetLitmus::PuppetHelpers
   # Applies a manifest twice. First checking for errors. Secondly to make sure no changes occur.
   #
   # @param manifest [String] puppet manifest code to be applied.
+  # @param opts [Hash] Alters the behaviour of the command. Valid options are:
+  #  :catch_changes [Boolean] (false) We're after idempotency so allow exit code 0 only.
+  #  :expect_changes [Boolean] (false) We're after changes specifically so allow exit code 2 only.
+  #  :catch_failures [Boolean] (false) We're after only complete success so allow exit codes 0 and 2 only.
+  #  :expect_failures [Boolean] (false) We're after failures specifically so allow exit codes 1, 4, and 6 only.
+  #  :manifest_file_location [Path] The place on the target system.
+  #  :hiera_config [Path] The path to the hiera.yaml configuration on the target.
+  #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".
+  #  :trace [Boolean] run puppet apply with the trace flag (defaults to `true`).
+  #  :debug [Boolean] run puppet apply with the debug flag.
+  #  :noop [Boolean] run puppet apply with the noop flag.
   # @return [Boolean] The result of the 2 apply manifests.
-  def idempotent_apply(manifest)
+  def idempotent_apply(manifest, opts = {})
     Honeycomb.start_span(name: 'litmus.idempotent_apply') do |span|
       ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       manifest_file_location = create_manifest_file(manifest)
-      apply_manifest(nil, catch_failures: true, manifest_file_location: manifest_file_location)
-      apply_manifest(nil, catch_changes: true, manifest_file_location: manifest_file_location)
+      apply_manifest(nil, **opts, catch_failures: true, manifest_file_location: manifest_file_location)
+      apply_manifest(nil, **opts, catch_changes: true, manifest_file_location: manifest_file_location)
     end
   end
 
@@ -70,10 +81,15 @@ module PuppetLitmus::PuppetHelpers
 
       manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
       inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      span.add_field('litmus.node_name', target_node_name)
-      add_platform_field(inventory_hash, target_node_name)
+      target_option = opts['targets'] || opts[:targets]
+      if target_option.nil?
+        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      else
+        target_node_name = search_for_target(target_option, inventory_hash)
+      end
+
+      add_node_fields_to_span(span, target_node_name, inventory_hash)
 
       # Forcibly set the locale of the command
       locale = if os[:family] != 'windows'
@@ -132,7 +148,7 @@ module PuppetLitmus::PuppetHelpers
   #
   # @param manifest [String] puppet manifest code.
   # @return [String] The path to the location of the manifest.
-  def create_manifest_file(manifest)
+  def create_manifest_file(manifest, opts = {})
     Honeycomb.start_span(name: 'litmus.create_manifest_file') do |span|
       ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.manifest', manifest)
@@ -149,8 +165,9 @@ module PuppetLitmus::PuppetHelpers
       else
         # transfer to TARGET_HOST
         inventory_hash = inventory_hash_from_inventory_file
-        span.add_field('litmus.node_name', target_node_name)
-        add_platform_field(inventory_hash, target_node_name)
+        target_option = opts['targets'] || opts[:targets]
+        target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
+        add_node_fields_to_span(span, target_node_name, inventory_hash)
 
         manifest_file_location = File.basename(manifest_file)
         bolt_result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
@@ -169,13 +186,16 @@ module PuppetLitmus::PuppetHelpers
   # @param content [String] String data to write to the file.
   # @param destination [String] The path on the target node to write the file.
   # @return [Bool] Success. The file was succesfully writtne on the target.
-  def write_file(content, destination)
+  def write_file(content, destination, opts = {})
     Honeycomb.start_span(name: 'litmus.write_file') do |span|
       ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.destination', destination)
 
       require 'tmpdir'
+      inventory_hash = inventory_hash_from_inventory_file
       target_node_name = ENV['TARGET_HOST']
+      target_option = opts['targets'] || opts[:targets]
+      target_node_name = search_for_target(target_option, inventory_hash) unless target_option.nil?
 
       Tempfile.create('litmus') do |tmp_file|
         tmp_file.write(content)
@@ -186,9 +206,7 @@ module PuppetLitmus::PuppetHelpers
           FileUtils.cp(tmp_file.path, destination)
         else
           # transfer to TARGET_HOST
-          inventory_hash = inventory_hash_from_inventory_file
-          span.add_field('litmus.node_name', target_node_name)
-          add_platform_field(inventory_hash, target_node_name)
+          add_node_fields_to_span(span, target_node_name, inventory_hash)
 
           bolt_result = upload_file(tmp_file.path, destination, target_node_name, options: {}, config: nil, inventory: inventory_hash)
           span.add_field('litmus.bolt_result.file_upload', bolt_result)
@@ -212,12 +230,17 @@ module PuppetLitmus::PuppetHelpers
       span.add_field('litmus.command_to_run', command_to_run)
       span.add_field('litmus.opts', opts)
 
-      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      span.add_field('litmus.node_name', target_node_name)
-      add_platform_field(inventory_hash, target_node_name)
+      target_option = opts['targets'] || opts[:targets]
+      if target_option.nil?
+        target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
+        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      else
+        target_node_name = search_for_target(target_option, inventory_hash)
+      end
+
+      add_node_fields_to_span(span, target_node_name, inventory_hash)
 
       bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
       span.add_field('litmus.bolt_result', bolt_result)
@@ -251,12 +274,16 @@ module PuppetLitmus::PuppetHelpers
       span.add_field('litmus.opts', opts)
       span.add_field('litmus.options', options)
 
-      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      target_option = opts['targets'] || opts[:targets]
+      if target_option.nil?
+        target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
+        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      else
+        target_node_name = search_for_target(target_option, inventory_hash)
+      end
 
-      span.add_field('litmus.node_name', target_node_name)
-      add_platform_field(inventory_hash, target_node_name)
+      add_node_fields_to_span(span, target_node_name, inventory_hash)
 
       bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
       span.add_field('litmus.bolt_result', bolt_result)
@@ -311,10 +338,15 @@ module PuppetLitmus::PuppetHelpers
                        else
                          localhost_inventory_hash
                        end
-      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
-      span.add_field('litmus.node_name', target_node_name)
-      add_platform_field(inventory_hash, target_node_name)
+      target_option = opts['targets'] || opts[:targets]
+      if target_option.nil?
+        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      else
+        target_node_name = search_for_target(target_option, inventory_hash)
+      end
+
+      add_node_fields_to_span(span, target_node_name, inventory_hash)
 
       bolt_result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
       result_obj = {
@@ -372,10 +404,14 @@ module PuppetLitmus::PuppetHelpers
 
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('spec/fixtures/litmus_inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-      raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      target_option = opts['targets'] || opts[:targets]
+      if target_option.nil?
+        raise "Target '#{target_node_name}' not found in spec/fixtures/litmus_inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      else
+        target_node_name = search_for_target(target_option, inventory_hash)
+      end
 
-      span.add_field('litmus.node_name', target_node_name)
-      add_platform_field(inventory_hash, target_node_name)
+      add_node_fields_to_span(span, target_node_name, inventory_hash)
 
       bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
 

data/lib/puppet_litmus/rake_helper.rb

@@ -464,7 +464,7 @@ module PuppetLitmus::RakeHelper
 
   class LitmusTimeoutError < StandardError; end
 
-  def with_retries(options: { tries: Float::INFINITY }, max_wait_minutes: 8)
+  def with_retries(options: { tries: Float::INFINITY }, max_wait_minutes: 15)
     stop = Time.now + (max_wait_minutes * 60)
     Retryable.retryable(options.merge(not: [LitmusTimeoutError])) do
       raise LitmusTimeoutError if Time.now > stop

data/lib/puppet_litmus/version.rb

@@ -2,5 +2,5 @@
 
 # version of this gem
 module PuppetLitmus
-  VERSION ||= '0.27.0'
+  VERSION ||= '0.31.0'
 end

data/spec/exe/fake_metadata.json

@@ -0,0 +1,46 @@
+{
+  "name": "puppetlabs-fake_module",
+  "version": "3.1.0",
+  "author": "puppetlabs",
+  "summary": "fake_module is a test",
+  "license": "Apache-2.0",
+  "source": "it has no source",
+  "project_page": "it has no project page",
+  "issues_url": "https://tickets.puppetlabs.com/browse/MODULES",
+  "dependencies": [
+    {
+      "name": "puppetlabs/stdlib",
+      "version_requirement": ">= 4.0.0 < 9.0.0"
+    }
+  ],
+  "operatingsystem_support": [
+    {
+      "operatingsystem": "CentOS",
+      "operatingsystemrelease": [
+        "6"
+      ]
+    },
+    {
+      "operatingsystem": "RedHat",
+      "operatingsystemrelease": [
+        "8"
+      ]
+    },
+    {
+      "operatingsystem": "Ubuntu",
+      "operatingsystemrelease": [
+        "14.04",
+        "18.04"
+      ]
+    }
+  ],
+  "requirements": [
+    {
+      "name": "puppet",
+      "version_requirement": ">= 6.0.0 < 8.0.0"
+    }
+  ],
+  "template-url": "https://github.com/puppetlabs/pdk-templates.git#main",
+  "template-ref": "heads/main-0-g2381db6",
+  "pdk-version": "2.1.1"
+}

data/spec/exe/matrix_from_metadata_v2_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'matrix_from_metadata_v2' do
+  context 'without arguments' do
+    let(:result) { run_matrix_from_metadata_v2 }
+
+    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 Ubuntu-14.04')
+      expect(result.stdout).to include(
+        [
+          '::set-output name=matrix::{',
+          '"platforms":[',
+          '{"label":"CentOS-6","provider":"provision::docker","image":"litmusimage/centos:6"},',
+          '{"label":"RedHat-8","provider":"provision::provision_service","image":"rhel-8"},',
+          '{"label":"Ubuntu-18.04","provider":"provision::docker","image":"litmusimage/ubuntu:18.04"}',
+          '],',
+          '"collection":[',
+          '"puppet6-nightly","puppet7-nightly"',
+          ']',
+          '}',
+        ].join,
+      )
+      expect(result.stdout).to include(
+        '::set-output name=spec_matrix::{"include":[{"puppet_version":"~> 6.0","ruby_version":2.5},{"puppet_version":"~> 7.0","ruby_version":2.7}]}',
+      )
+      expect(result.stdout).to include("Created matrix with 8 cells:\n  - Acceptance Test Cells: 6\n  - Spec Test Cells: 2")
+    end
+  end
+
+  context 'with --exclude-platforms ["ubuntu-18.04"]' do
+    let(:result) { run_matrix_from_metadata_v2({ '--exclude-platforms' => ['ubuntu-18.04'] }) }
+
+    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::Cannot find image for Ubuntu-14.04')
+      expect(result.stdout).to include('::warning::Ubuntu-18.04 was excluded from testing')
+      expect(result.stdout).to include(
+        [
+          '::set-output name=matrix::{',
+          '"platforms":[',
+          '{"label":"CentOS-6","provider":"provision::docker","image":"litmusimage/centos:6"},',
+          '{"label":"RedHat-8","provider":"provision::provision_service","image":"rhel-8"}',
+          '],',
+          '"collection":[',
+          '"puppet6-nightly","puppet7-nightly"',
+          ']',
+          '}',
+        ].join,
+      )
+      expect(result.stdout).to include(
+        '::set-output name=spec_matrix::{"include":[{"puppet_version":"~> 6.0","ruby_version":2.5},{"puppet_version":"~> 7.0","ruby_version":2.7}]}',
+      )
+      expect(result.stdout).to include("Created matrix with 6 cells:\n  - Acceptance Test Cells: 4\n  - Spec Test Cells: 2")
+    end
+  end
+
+  context 'with --exclude-platforms \'["ubuntu-18.04","redhat-8"]\'' do
+    let(:result) { run_matrix_from_metadata_v2({ '--exclude-platforms' => ['ubuntu-18.04', 'redhat-8'] }) }
+
+    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::Cannot find image for Ubuntu-14.04')
+      expect(result.stdout).to include('::warning::Ubuntu-18.04 was excluded from testing')
+      expect(result.stdout).to include('::warning::RedHat-8 was excluded from testing')
+      expect(result.stdout).to include(
+        [
+          '::set-output name=matrix::{',
+          '"platforms":[',
+          '{"label":"CentOS-6","provider":"provision::docker","image":"litmusimage/centos:6"}',
+          '],',
+          '"collection":[',
+          '"puppet6-nightly","puppet7-nightly"',
+          ']',
+          '}',
+        ].join,
+      )
+      expect(result.stdout).to include(
+        '::set-output name=spec_matrix::{"include":[{"puppet_version":"~> 6.0","ruby_version":2.5},{"puppet_version":"~> 7.0","ruby_version":2.7}]}',
+      )
+      expect(result.stdout).to include("Created matrix with 4 cells:\n  - Acceptance Test Cells: 2\n  - Spec Test Cells: 2")
+    end
+  end
+end