puppet_litmus 0.18.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b57432738dbfa9e3c83c891565286c43703437df4d4b8f3a1c09431012dd869d
-  data.tar.gz: 7d4213842c29f689b943dea1a89fc1ea5c4cda272a67fad70c2d55a9b74114a8
+  metadata.gz: 6b3fcb695b5204b13b091211f12201ade70cd34af04ad8aefd81856f5b212116
+  data.tar.gz: 4f941ab55af8dbed7848e39fbdbeba76586aabce36a1a52194d76cee6680ecf3
 SHA512:
-  metadata.gz: 01344ef395005540dc7ae2d109b19e6bf94064f0a27031e886c2f114cdaec8c33c6cbcd71c57a0c164b4724cc5014fb17b7b8ddf12220189f2e10bb22ead26b7
-  data.tar.gz: 4f6a4144f1785e618d40560463de94e874d03208c1a35ba2ca3d031752e9791b133466105f45b50e4ef59f0f12a3e0736e606d2140d0e517b63c633a0dd7aae6
+  metadata.gz: 8254a6ec0ffe6a9d398730de3a4c5878330ece15912ebc39d560bb3e811616e05319f4577434d457088e44f48391e043579f808ec5d4628e2ed0bd49843bbf70
+  data.tar.gz: cb009e0328b4373a3fccb987a02c143f0b61bd5ae6c3718ee9adb6553242b057a0674dc84cb13f6aa0f31821a130aeec1db8498a8957dbe5ba8eb2a2263332b5

data/lib/puppet_litmus.rb

@@ -4,7 +4,6 @@
 module PuppetLitmus; end
 
 require 'bolt_spec/run'
-require 'puppet_litmus/honeycomb_utils'
 require 'puppet_litmus/inventory_manipulation'
 require 'puppet_litmus/puppet_helpers'
 require 'puppet_litmus/rake_helper'

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -235,7 +235,7 @@ module PuppetLitmus::InventoryManipulation
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
   # @param feature_name [String] feature to locate in the node
-  # node_name [String] node of nodes to limit the search for the node_name in
+  # @param node_name [String] node of nodes to limit the search for the node_name in
   # @return inventory.yaml file with feature removed from the node.
   # @return [Hash] inventory_hash with feature added to node if node_name exists in inventory hash.
   def remove_feature_from_node(inventory_hash, feature_name, node_name)
@@ -257,4 +257,13 @@ module PuppetLitmus::InventoryManipulation
   def write_to_inventory_file(inventory_hash, inventory_full_path)
     File.open(inventory_full_path, 'wb+') { |f| f.write(inventory_hash.to_yaml) }
   end
+
+  # Add the `litmus.platform` with platform information for the target
+  #
+  # @param inventory_hash [Hash] hash of the inventory.yaml file
+  # @param node_name [String] node of nodes to limit the search for the node_name in
+  def add_platform_field(inventory_hash, node_name)
+    facts = facts_from_node(inventory_hash, node_name)
+    Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
+  end
 end

data/lib/puppet_litmus/puppet_helpers.rb

@@ -73,7 +73,7 @@ module PuppetLitmus::PuppetHelpers
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
       span.add_field('litmus.node_name', target_node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
       command_to_run += ' --trace' if !opts[:trace].nil? && (opts[:trace] == true)
@@ -133,7 +133,7 @@ module PuppetLitmus::PuppetHelpers
         # transfer to TARGET_HOST
         inventory_hash = inventory_hash_from_inventory_file
         span.add_field('litmus.node_name', target_node_name)
-        PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+        add_platform_field(inventory_hash, target_node_name)
 
         manifest_file_location = "/tmp/#{File.basename(manifest_file)}"
         bolt_result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
@@ -164,7 +164,7 @@ module PuppetLitmus::PuppetHelpers
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
       span.add_field('litmus.node_name', target_node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
       span.add_field('litmus.bolt_result', bolt_result)
@@ -203,7 +203,7 @@ module PuppetLitmus::PuppetHelpers
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
       span.add_field('litmus.node_name', target_node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
       span.add_field('litmus.bolt_result', bolt_result)
@@ -261,7 +261,7 @@ module PuppetLitmus::PuppetHelpers
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
       span.add_field('litmus.node_name', target_node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
       result_obj = {
@@ -322,7 +322,7 @@ module PuppetLitmus::PuppetHelpers
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
 
       span.add_field('litmus.node_name', target_node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
 

data/lib/puppet_litmus/rake_helper.rb

@@ -2,7 +2,6 @@
 
 require 'bolt_spec/run'
 require 'honeycomb-beeline'
-require 'puppet_litmus/honeycomb_utils'
 Honeycomb.configure do |config|
   # override client if no configuration is provided, so that the pesky libhoney warning about lack of configuration is not shown
   unless ENV['HONEYCOMB_WRITEKEY'] && ENV['HONEYCOMB_DATASET']
@@ -167,7 +166,7 @@ module PuppetLitmus::RakeHelper
       # how do we know what provisioner to use
 
       span.add_field('litmus.node_name', node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, node_name)
+      add_platform_field(inventory_hash, node_name)
 
       params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
       node_facts = facts_from_node(inventory_hash, node_name)
@@ -301,7 +300,7 @@ module PuppetLitmus::RakeHelper
       # if we're only checking connectivity for a single node
       if target_node_name
         span.add_field('litmus.node_name', target_node_name)
-        PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+        add_platform_field(inventory_hash, target_node_name)
       end
 
       include ::BoltSpec::Run

data/lib/puppet_litmus/rake_tasks.rb

@@ -354,8 +354,12 @@ namespace :litmus do
 
           require 'parallel'
           results = Parallel.map(payloads) do |title, test, options|
+            # avoid sending the parent process' main span in the sub-processes
+            # https://www.ruby-forum.com/t/at-exit-inherited-across-fork/122473/2
+            at_exit { exit! }
+
             env = options[:env].nil? ? {} : options[:env]
-            ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+            env['HTTP_X_HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
             stdout, stderr, status = Open3.capture3(env, test)
             ["\n================\n#{title}\n", stdout, stderr, status]
           end
@@ -373,8 +377,8 @@ namespace :litmus do
           spinners = TTY::Spinner::Multi.new("[:spinner] Running against #{targets.size} targets.")
           payloads.each do |title, test, options|
             env = options[:env].nil? ? {} : options[:env]
+            env['HTTP_X_HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
             spinners.register("[:spinner] #{title}") do |sp|
-              ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
               stdout, stderr, status = Open3.capture3(env, test)
               if status.to_i.zero?
                 sp.success

data/lib/puppet_litmus/version.rb

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

data/spec/lib/puppet_litmus/inventory_manipulation_spec.rb

@@ -92,70 +92,70 @@ RSpec.describe PuppetLitmus::InventoryManipulation do
     end
 
     it 'no matching node, raises' do
-      expect { described_class.config_from_node(config_hash, 'not.here') }.to raise_error('No config was found for not.here')
+      expect { config_from_node(config_hash, 'not.here') }.to raise_error('No config was found for not.here')
     end
 
     it 'no config section, returns nil' do
-      expect(described_class.config_from_node(no_config_hash, 'test.delivery.puppetlabs.net')).to eq(nil)
+      expect(config_from_node(no_config_hash, 'test.delivery.puppetlabs.net')).to eq(nil)
     end
 
     it 'config exists, and returns' do
-      expect(described_class.config_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('transport' => 'ssh', 'ssh' =>
+      expect(config_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('transport' => 'ssh', 'ssh' =>
 { 'user' => 'root', 'password' => 'Qu@lity!', 'host-key-check' => false })
     end
 
     it 'facts exists, and returns' do
-      expect(described_class.facts_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64')
+      expect(facts_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64')
     end
 
     it 'vars exists, and returns' do
-      expect(described_class.vars_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('role' => 'agent')
+      expect(vars_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('role' => 'agent')
     end
 
     it 'no feature exists for the group, and returns hash with feature added' do
-      expect(described_class.add_feature_to_group(no_feature_hash, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_group(no_feature_hash, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'feature exists for the group, and returns hash with feature removed' do
-      expect(described_class.remove_feature_from_group(feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => [], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(remove_feature_from_group(feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => [], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file feature_hash_group' do
-      expect { described_class.write_to_inventory_file(feature_hash_group, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(feature_hash_group, inventory_full_path) }.not_to raise_error
     end
 
     it 'empty feature exists for the group, and returns hash with feature added' do
-      expect(described_class.add_feature_to_group(empty_feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_group(empty_feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'no feature exists for the node, and returns hash with feature added' do
-      expect(described_class.add_feature_to_node(no_feature_hash, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_node(no_feature_hash, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'feature exists for the node, and returns hash with feature removed' do
-      expect(described_class.remove_feature_from_node(feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => [] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(remove_feature_from_node(feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => [] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file feature_hash_node' do
-      expect { described_class.write_to_inventory_file(feature_hash_node, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(feature_hash_node, inventory_full_path) }.not_to raise_error
     end
 
     it 'empty feature exists for the node, and returns hash with feature added' do
-      expect(described_class.add_feature_to_node(empty_feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_node(empty_feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file no feature_hash' do
       expect(File).to exist(inventory_full_path)
-      expect { described_class.write_to_inventory_file(no_feature_hash, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(no_feature_hash, inventory_full_path) }.not_to raise_error
     end
 
     it 'group does not exist in inventory, and returns hash with group added' do
-      expect(described_class.add_node_to_group(no_docker_hash, foo_node, 'docker_nodes')).to eq('groups' =>
+      expect(add_node_to_group(no_docker_hash, foo_node, 'docker_nodes')).to eq('groups' =>
         [{ 'name' => 'ssh_nodes', 'targets' => [] }, { 'name' => 'winrm_nodes', 'targets' => [] }, { 'name' => 'docker_nodes', 'targets' => [foo_node] }])
     end
 
     it 'group exists in inventory, and returns hash with node added' do
-      expect(described_class.add_node_to_group(no_docker_hash, foo_node, 'ssh_nodes')).to eq('groups' =>
+      expect(add_node_to_group(no_docker_hash, foo_node, 'ssh_nodes')).to eq('groups' =>
         [{ 'name' => 'ssh_nodes', 'targets' => [foo_node] }, { 'name' => 'winrm_nodes', 'targets' => [] }])
     end
   end

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb

@@ -13,10 +13,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     end
 
     it 'calls all functions' do
-      expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-      expect(described_class).to receive(:apply_manifest).with(nil, expect_failures: false, manifest_file_location: '/bla.pp')
-      expect(described_class).to receive(:apply_manifest).with(nil, catch_changes: true, manifest_file_location: '/bla.pp')
-      described_class.idempotent_apply(manifest)
+      expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+      expect(self).to receive(:apply_manifest).with(nil, expect_failures: false, manifest_file_location: '/bla.pp')
+      expect(self).to receive(:apply_manifest).with(nil, catch_changes: true, manifest_file_location: '/bla.pp')
+      idempotent_apply(manifest)
     end
   end
 
@@ -28,11 +28,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
 
       it 'passes the --hiera_config flag if the :hiera_config opt is specified' do
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, hiera_config: '/hiera.yaml')
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        apply_manifest(manifest, hiera_config: '/hiera.yaml')
       end
     end
 
@@ -43,42 +42,38 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
 
       it 'uses detailed-exitcodes with expect_failures' do
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.apply_manifest(manifest, expect_failures: true) }.to raise_error(RuntimeError)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { apply_manifest(manifest, expect_failures: true) }.to raise_error(RuntimeError)
       end
 
       it 'uses detailed-exitcodes with catch_failures' do
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, catch_failures: true)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        apply_manifest(manifest, catch_failures: true)
       end
 
       it 'uses detailed-exitcodes with expect_changes' do
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.apply_manifest(manifest, expect_changes: true) }.to raise_error(RuntimeError)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { apply_manifest(manifest, expect_changes: true) }.to raise_error(RuntimeError)
       end
 
       it 'uses detailed-exitcodes with catch_changes' do
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, catch_changes: true)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        apply_manifest(manifest, catch_changes: true)
       end
 
       it 'uses raises exception for multiple options' do
-        expect { described_class.apply_manifest(manifest, catch_changes: true, expect_failures: true) }
+        expect { apply_manifest(manifest, catch_changes: true, expect_failures: true) }
           .to raise_error(RuntimeError, 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`')
       end
     end
@@ -89,17 +84,16 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:result) { ['value' => { 'exit_code' => 0, 'exit_status' => 0, 'stdout' => nil, 'stderr' => nil }] }
 
     it 'responds to run_shell' do
-      expect(described_class).to respond_to(:run_shell).with(1..2).arguments
+      expect(self).to respond_to(:run_shell).with(1..2).arguments
     end
 
     context 'when running against localhost and no inventory.yaml file' do
       it 'does run_shell against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.run_shell(command_to_run) }.not_to raise_error
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { run_shell(command_to_run) }.not_to raise_error
       end
     end
 
@@ -107,10 +101,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does run_shell against remote host without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
-        expect { described_class.run_shell(command_to_run) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
+        expect { run_shell(command_to_run) }.not_to raise_error
       end
     end
   end
@@ -125,27 +119,26 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     # rubocop:enable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
 
     it 'responds to run_shell' do
-      expect(described_class).to respond_to(:bolt_upload_file).with(2..3).arguments
+      expect(self).to respond_to(:bolt_upload_file).with(2..3).arguments
     end
 
     context 'when upload returns success' do
       it 'does upload_file against remote host without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
-        expect { described_class.bolt_upload_file(local, remote) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
+        expect { bolt_upload_file(local, remote) }.not_to raise_error
       end
 
       it 'does upload_file against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
-        expect { described_class.bolt_upload_file(local, remote) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
+        expect { bolt_upload_file(local, remote) }.not_to raise_error
       end
     end
 
@@ -153,19 +146,19 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does upload_file gives runtime error for failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
-        expect { described_class.bolt_upload_file(local, remote) }.to raise_error(RuntimeError, %r{upload file failed})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
+        expect { bolt_upload_file(local, remote) }.to raise_error(RuntimeError, %r{upload file failed})
       end
 
       it 'returns the exit code and error message when expecting failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
-        method_result = described_class.bolt_upload_file(local, remote, expect_failures: true)
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
+        method_result = bolt_upload_file(local, remote, expect_failures: true)
         expect(method_result.exit_code).to be(255)
         expect(method_result.stderr).to be('No such file or directory @ rb_sysopen - /nonexistant/file/path')
       end
@@ -177,18 +170,17 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:result) { ['value' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
 
     it 'responds to bolt_run_script' do
-      expect(described_class).to respond_to(:bolt_run_script).with(1..2).arguments
+      expect(self).to respond_to(:bolt_run_script).with(1..2).arguments
     end
 
     context 'when running against localhost and no inventory.yaml file' do
       it 'does bolt_run_script against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { bolt_run_script(script) }.not_to raise_error
       end
     end
 
@@ -196,10 +188,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does bolt_run_script against remote host without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
+        expect { bolt_run_script(script) }.not_to raise_error
       end
     end
 
@@ -207,11 +199,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does bolt_run_script with arguments without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
       end
     end
   end
@@ -228,45 +219,45 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     # rubocop:enable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceBeforeBlockBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
 
     it 'responds to bolt_run_task' do
-      expect(described_class).to respond_to(:run_bolt_task).with(2..3).arguments
+      expect(self).to respond_to(:run_bolt_task).with(2..3).arguments
     end
 
     context 'when bolt returns success' do
       it 'does bolt_task_run gives no runtime error for success' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        expect { described_class.run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        expect { run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
       end
 
       it 'does bolt_task_run gives no runtime error for success, for a named inventory file' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('jim.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        expect { described_class.run_bolt_task(task_name, params, inventory_file: 'jim.yaml') }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        expect { run_bolt_task(task_name, params, inventory_file: 'jim.yaml') }.not_to raise_error
       end
 
       it 'returns stdout for unstructured-data tasks' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        method_result = described_class.run_bolt_task(task_name, params, opts: {})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        method_result = run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('SUCCESS!')
       end
 
       it 'returns structured output for structured-data tasks' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
-        method_result = described_class.run_bolt_task(task_name, params, opts: {})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
+        method_result = run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('{"key1"=>"foo", "key2"=>"bar"}')
         expect(method_result.result['key1']).to eq('foo')
         expect(method_result.result['key2']).to eq('bar')
@@ -277,19 +268,19 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does bolt_task_run gives runtime error for failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
-        expect { described_class.run_bolt_task(task_name, params, opts: {}) }.to raise_error(RuntimeError, %r{task failed})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
+        expect { run_bolt_task(task_name, params, opts: {}) }.to raise_error(RuntimeError, %r{task failed})
       end
 
       it 'returns the exit code and error message when expecting failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
-        method_result = described_class.run_bolt_task(task_name, params, expect_failures: true)
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
+        method_result = run_bolt_task(task_name, params, expect_failures: true)
         expect(method_result.exit_code).to be(123)
         expect(method_result.stderr).to be('FAILURE!')
       end

data/spec/lib/puppet_litmus/rake_helper_spec.rb

@@ -13,12 +13,12 @@ RSpec.shared_examples 'supported provisioner' do |args|
   it 'calls function' do
     allow(File).to receive(:directory?).and_call_original
     allow(File).to receive(:directory?)
-      .with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
+      .with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
       .and_return(true)
     allow_any_instance_of(BoltSpec::Run).to receive(:run_task)
-      .with("provision::#{provisioner}", 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      .with("provision::#{provisioner}", 'localhost', params, config: described_class::DEFAULT_CONFIG_DATA, inventory: nil)
       .and_return(results)
-    result = described_class.provision(provisioner, platform, inventory_vars)
+    result = provision(provisioner, platform, inventory_vars)
     expect(result).to eq(results)
   end
 end
@@ -29,8 +29,8 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:results) { [] }
 
     it 'calls function' do
-      expect(described_class).to receive(:provision).with('docker', 'waffleimage/centos7', nil).and_return(results)
-      described_class.provision_list(provision_hash, 'default')
+      expect(self).to receive(:provision).with('docker', 'waffleimage/centos7', nil).and_return(results)
+      provision_list(provision_hash, 'default')
     end
   end
 
@@ -71,9 +71,9 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:params) { { 'action' => 'tear_down', 'node_name' => 'some.host', 'inventory' => Dir.pwd } }
 
     it 'calls function' do
-      allow(File).to receive(:directory?).with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
-      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::docker', 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil).and_return([])
-      described_class.tear_down_nodes(targets, inventory_hash)
+      allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
+      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::docker', 'localhost', params, config: described_class::DEFAULT_CONFIG_DATA, inventory: nil).and_return([])
+      tear_down_nodes(targets, inventory_hash)
     end
   end
 
@@ -87,9 +87,9 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:params) { { 'collection' => 'puppet6' } }
 
     it 'calls function' do
-      allow(File).to receive(:directory?).with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent')).and_return(true)
-      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash).and_return([])
-      described_class.install_agent('puppet6', targets, inventory_hash)
+      allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent')).and_return(true)
+      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('puppet_agent::install', targets, params, config: described_class::DEFAULT_CONFIG_DATA, inventory: inventory_hash).and_return([])
+      install_agent('puppet6', targets, inventory_hash)
     end
   end
 
@@ -113,7 +113,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
                                         .and_return(['success', '', 0])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(install_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      described_class.install_module(inventory_hash, nil, module_tar)
+      install_module(inventory_hash, nil, module_tar)
     end
   end
 
@@ -129,12 +129,12 @@ RSpec.describe PuppetLitmus::RakeHelper do
     it 'node available' do
       allow(Open3).to receive(:capture3).with('cd .').and_return(['success', '', 0])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'success' }])
-      described_class.check_connectivity?(inventory_hash, 'some.host')
+      check_connectivity?(inventory_hash, 'some.host')
     end
 
     it 'node unavailable' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'failure' }])
-      expect { described_class.check_connectivity?(inventory_hash, 'some.host') }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
+      expect { check_connectivity?(inventory_hash, 'some.host') }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
     end
   end
 
@@ -149,13 +149,13 @@ RSpec.describe PuppetLitmus::RakeHelper do
 
     it 'uninstalls module' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      expect(described_class).to receive(:metadata_module_name).and_return('foo-bar')
-      described_class.uninstall_module(inventory_hash, nil)
+      expect(self).to receive(:metadata_module_name).and_return('foo-bar')
+      uninstall_module(inventory_hash, nil)
     end
 
     it 'and custom name' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      described_class.uninstall_module(inventory_hash, nil, 'foo-bar')
+      uninstall_module(inventory_hash, nil, 'foo-bar')
     end
   end
 
@@ -165,7 +165,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
     it 'reads module name' do
       allow(File).to receive(:exist?).with(File.join(Dir.pwd, 'metadata.json')).and_return(true)
       allow(File).to receive(:read).with(File.join(Dir.pwd, 'metadata.json')).and_return(metadata)
-      name = described_class.metadata_module_name
+      name = metadata_module_name
       expect(name).to eq('foo-bar')
     end
   end
@@ -173,12 +173,12 @@ RSpec.describe PuppetLitmus::RakeHelper do
   context 'with provisioner_task' do
     described_class::SUPPORTED_PROVISIONERS.each do |supported_provisioner|
       it "returns supported provisioner task name for #{supported_provisioner}" do
-        expect(described_class.provisioner_task(supported_provisioner)).to eq("provision::#{supported_provisioner}")
+        expect(provisioner_task(supported_provisioner)).to eq("provision::#{supported_provisioner}")
       end
     end
 
     it 'returns an unsupported provisioner name' do
-      expect(described_class.provisioner_task('my_org::custom_provisioner')).to eql('my_org::custom_provisioner')
+      expect(provisioner_task('my_org::custom_provisioner')).to eql('my_org::custom_provisioner')
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,6 @@
 # frozen_string_literal: true
 
 require 'rspec'
-require 'puppet_litmus'
-
-# Unfortunately this needs to be included as this is
-# how Litmus functions. We only include once here instead
-# of including for every single spec file.
-include PuppetLitmus # rubocop:disable Style/MixinUsage
 
 if ENV['COVERAGE'] == 'yes'
   require 'simplecov'
@@ -37,3 +31,10 @@ if ENV['COVERAGE'] == 'yes'
     end
   end
 end
+
+# This is basically how `configure!` sets up RSpec in tests.
+require 'puppet_litmus'
+RSpec.configure do |config|
+  config.include PuppetLitmus
+  config.extend PuppetLitmus
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.18.1
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2020-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -151,7 +151,6 @@ files:
 - LICENSE
 - README.md
 - lib/puppet_litmus.rb
-- lib/puppet_litmus/honeycomb_utils.rb
 - lib/puppet_litmus/inventory_manipulation.rb
 - lib/puppet_litmus/puppet_helpers.rb
 - lib/puppet_litmus/rake_helper.rb
@@ -201,7 +200,7 @@ test_files:
 - spec/lib/puppet_litmus/util_spec.rb
 - spec/lib/puppet_litmus/version_spec.rb
 - spec/lib/puppet_litmus/inventory_manipulation_spec.rb
-- spec/lib/puppet_litmus/rake_helper_spec.rb
 - spec/lib/puppet_litmus/puppet_helpers_spec.rb
 - spec/lib/puppet_litmus/rake_tasks_spec.rb
+- spec/lib/puppet_litmus/rake_helper_spec.rb
 - spec/spec_helper.rb

data/lib/puppet_litmus/honeycomb_utils.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module PuppetLitmus; end # rubocop:disable Style/Documentation
-
-# a set of semi-private utility functions that should not contaminate the global namespace
-module PuppetLitmus::HoneycombUtils
-  module_function
-
-  def add_platform_field(inventory_hash, target_node_name)
-    facts = facts_from_node(inventory_hash, target_node_name)
-    Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
-  end
-end