puppet-check 2.4.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5c74c1af6aee54ad5dcfd3eeefa459ed9fd5eaaafdc847f346a8e3674ffb362
-  data.tar.gz: c11db9238470434a489608d62360d12fe1ff10dda29627a05cdded940785b992
+  metadata.gz: a3c5911fe2362e7462d111f97705eea6b60842ce107bb94d35e6f8657cea6812
+  data.tar.gz: 52413822ec2375afd5fab3bb933220ad15bbcab285641f6717d94057c7fe0554
 SHA512:
-  metadata.gz: 12416f0a0d2d2615c467645cb238e0b14be8f42c9172e5adf7acf3bfbdddbdae1d5b08ccd2a967dcb7b6af41a8149f2e30e22ed5d0db97c5f05e586e384c4a61
-  data.tar.gz: 053f4f90842f2d71ccbc82a3b05cd5ef1347af5399686fc3ed4a7cbf824baeee63ad412c1d6261f3640929bdcba789db7e2fe46d7f3e529cf3cd6b1c8b9690d8
+  metadata.gz: fa0c790ee8186c5d1f2eb7091c78d789c68fef7d16292fe3a70c3d41a41d1eb65c3ece36462578bfe2874bb236316fa9b5737f7316f6902d1017bb15c182cf0a
+  data.tar.gz: 87e82df7685a13f4122838b225ef8e44d8de30b9e14f8cbb75577b76074fff5f40ca895c7bef00a7648862abba1edc31d5e237b0cb4ba8e0e5e1eb5aa4486304

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+### 2.5.1
+- Fix explicit `fail_on_warnings` default value assignment.
+- Improve message transformation for Puppet::Face errors and warnings.
+- Improve EYAML certification validation check.
+- Verify that files to be validated are readable by current user.
+- Fix Puppet 5.4-6.4 syntax error output format.
+
+### 2.5.0
+- Minimum Ruby version increased to 3.1.
+- Minimum Puppet-Lint increased to 5.0.
+- Restore ERB validation mock Ruby binding.
+- Update Reek API usage.
+- Ensure `rubocop-rspec` plugin only loaded for spec files.
+
 ### 2.4.0
 - Minimum Ruby version increased to 3.0.
 - Fix `rubocop-performance` inclusion warning.

data/README.md

@@ -331,6 +331,4 @@ To overcome the lack of convenient portability, you could try spinning up the Va
 ## Contributing
 Code should pass all spec tests. New features should involve new spec tests. Adherence to Rubocop and Reek is expected where not overly onerous or where the check is of dubious cost/benefit.
 
-A [Dockerfile](Dockerfile) is provided for easy rake testing. A [Vagrantfile](Vagrantfile) is provided for easy gem building, installation, and post-installation testing.
-
 Please consult the GitHub Project for the current development roadmap.

data/lib/puppet-check/data_parser.rb

@@ -33,9 +33,9 @@ class DataParser
     end
 
     # keys exist?
-    unless File.file?(public) && File.file?(private)
+    unless File.readable?(public) && File.readable?(private)
       PuppetCheck.files[:ignored].concat(files)
-      return warn 'Specified Public X509 and/or Private RSA PKCS7 certs do not exist. EYAML checks will not be executed.'
+      return warn 'Specified Public X509 and/or Private RSA PKCS7 certs do not exist or are not readable. EYAML checks will not be executed.'
     end
 
     # setup decryption

data/lib/puppet-check/puppet_parser.rb

@@ -32,12 +32,12 @@ class PuppetParser
         new_error = Puppet::Face[:parser, :current].validate(file)
         # puppet 6.5 output format is now a hash from the face api
         if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('6.5.0') && new_error != {}
-          messages.concat(new_error.values.map(&:to_s).map { |error| error.gsub(/ \(file: #{File.absolute_path(file)}(, |\))/, '') }.map { |error| error.gsub('Could not parse for environment *root*: ', '') })
+          messages.concat(new_error.values.map(&:to_s).map { |error| error.gsub(Regexp.escape(" (file: #{File.absolute_path(file)}(, |))"), '') }.map { |error| error.gsub('Could not parse for environment *root*: ', '') })
         end
       # this is the actual error that we need to rescue Puppet::Face from
       rescue SystemExit
         # puppet 5.4-6.4 has a new validator output format and eof errors have fake dir env info
-        messages.concat(errors.map(&:to_s).join("\n").map { |error| error.gsub(/file: #{File.absolute_path(file)}(, |\))/, '') }.map { |error| error.gsub(/Could not parse.*: /, '') })
+        messages.concat(errors.map(&:to_s).map { |error| error.gsub(Regexp.escape("file: #{File.absolute_path(file)}(, |))"), '') }.map { |error| error.gsub(/Could not parse.*: /, '') })
       end
 
       Puppet::Util::Log.close_all
@@ -50,7 +50,7 @@ class PuppetParser
       # weirdly puppet >= 6.5 still does not return warnings and logs them instead unlike errors
       unless errors.empty?
         # puppet >= 5.4 has a new validator output format
-        warnings.concat(errors.map(&:to_s).join("\n").gsub("file: #{File.absolute_path(file)}, ", '').split("\n"))
+        warnings.concat(errors.map(&:to_s).join("\n").gsub(Regexp.escape("file: #{File.absolute_path(file)}(, |))"), '').split("\n"))
       end
 
       # check puppet style

data/lib/puppet-check/ruby_parser.rb

@@ -10,7 +10,6 @@ class RubyParser
       require 'json'
       require 'rubocop'
       require 'reek'
-      require 'reek/cli/application'
 
       rubocop_cli = RuboCop::CLI.new
     end
@@ -23,13 +22,16 @@ class RubyParser
     else
       # check ruby style
       if style
+        # add rubocop rspec plugin if the file is a spec
+        rc_args.push('--plugin', 'rubocop-rspec') if file =~ /_spec\.rb$/
+
         # check RuboCop and parse warnings' JSON output
-        rubocop_warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--plugin', 'rubocop-performance', '--plugin', 'rubocop-rspec', '--format', 'json', file]) }
+        rubocop_warnings = Utils.capture_stdout { rubocop_cli.run(rc_args + ['--enable-pending-cops', '--plugin', 'rubocop-performance', '--format', 'json', file]) }
         rubocop_offenses = JSON.parse(rubocop_warnings)['files'][0]['offenses'].map { |warning| "#{warning['location']['line']}:#{warning['location']['column']} #{warning['message']}" }
 
-        # check Reek and parse warnings' JSON output
-        reek_warnings = Utils.capture_stdout { Reek::CLI::Application.new(['-f', 'json', file]).execute }
-        reek_offenses = JSON.parse(reek_warnings).map { |warning| "#{warning['lines'].join(',')}: #{warning['context']} #{warning['message']}" }
+        # check Reek using examiner api
+        examiner = Reek::Examiner.new(Pathname.new(file))
+        reek_offenses = examiner.smells.map { |warning| "#{warning.lines.join(',')}: #{warning.context} #{warning.message}" }
 
         # assign warnings from combined offenses
         warnings = rubocop_offenses + reek_offenses
@@ -48,10 +50,7 @@ class RubyParser
     files.each do |file|
       # check ruby template syntax
       begin
-        # need to eventually have this associated with a different binding during each iteration
-        # older usage throws extra warning and mixes with valid warnings confusingly
-        warnings = Utils.capture_stderr { ERB.new(File.read(file), trim_mode: '-').result }
-        # warnings = ERB.new(File.read(file), trim_mode: '-').result(RubyParser.new.bind)
+        warnings = Utils.capture_stderr { ERB.new(File.read(file), trim_mode: '-').result(Object.new.instance_eval { binding }) }
       rescue NameError, TypeError
         # empty out warnings since it would contain an error if this pass triggers
         warnings = ''
@@ -79,8 +78,7 @@ class RubyParser
 
     files.each do |file|
       # check librarian puppet syntax
-      # prevents ruby code from actually executing the input ruby file
-      catch(:good) { instance_eval("BEGIN {throw :good}; #{File.read(file)} # BEGIN {throw :good}; ruby_file_content", file) }
+      RubyVM::InstructionSequence.compile_file(file)
     rescue SyntaxError, LoadError, ArgumentError => err
       PuppetCheck.files[:errors][file] = err.to_s.gsub("#{file}:", '').split("\n")
     # check librarian puppet style
@@ -95,9 +93,4 @@ class RubyParser
       PuppetCheck.files[:clean].push(file.to_s)
     end
   end
-
-  # potentially for unique erb bindings
-  def bind
-    binding
-  end
 end

data/lib/puppet_check.rb

@@ -75,7 +75,7 @@ class PuppetCheck
     # return settings with defaults where unspecified
     {
       # initialize fail on warning,  style check, and regression check bools
-      fail_on_warning: false,
+      fail_on_warnings: false,
       style: false,
       smoke: false,
       regression: false,
@@ -101,11 +101,11 @@ class PuppetCheck
     paths.uniq.each do |path|
       if File.directory?(path)
         # glob all files in directory and concat them
-        files.concat(Dir.glob("#{path}/**/*").select { |subpath| File.file?(subpath) && !subpath.include?('fixtures') })
-      elsif File.file?(path) && !path.include?('fixtures')
+        files.concat(Dir.glob("#{path}/**/*").select { |subpath| File.file?(subpath) && File.readable?(subpath) && !subpath.include?('fixtures') })
+      elsif File.file?(path) && File.readable?(path) && !path.include?('fixtures')
         files.push(path)
       else
-        warn "puppet-check: #{path} is not a directory, file, or symlink, and will not be considered during parsing"
+        warn "puppet-check: #{path} is not a readable directory, file, or symlink, and will not be considered during parsing"
       end
     end
 

data/puppet-check.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = 'puppet-check'
-  spec.version       = '2.4.0'
+  spec.version       = '2.5.1'
   spec.authors       = ['Matt Schuchard']
   spec.description   = 'Puppet Check is a gem that provides a comprehensive, streamlined, and efficient analysis of the syntax, style, and validity of your entire Puppet code and data.'
   spec.summary       = 'A streamlined comprehensive set of checks for your entire Puppet code and data'
@@ -11,9 +11,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |file| File.basename(file) }
   spec.require_paths = Dir['lib']
 
-  spec.required_ruby_version = '>= 3.0.0'
+  spec.required_ruby_version = '>= 3.1.0'
   spec.add_dependency 'puppet', '>= 5.5', '< 9'
-  spec.add_dependency 'puppet-lint', '~> 4.0'
+  spec.add_dependency 'puppet-lint', '~> 5.0'
   spec.add_dependency 'reek', '~> 6.0'
   spec.add_dependency 'rubocop', '~> 1.72'
   spec.add_dependency 'rubocop-performance', '~> 1.0'

data/spec/puppet-check/cli_spec.rb

@@ -5,8 +5,8 @@ describe PuppetCheck::CLI do
   context '.run' do
     it 'targets the current working directory if no paths were specified' do
       expect { PuppetCheck::CLI.run(%w[--fail-on-warnings]) }.not_to raise_exception
-      expect(PuppetCheck.files[:clean].length).to eql(30)
-      if ci_env
+      expect(PuppetCheck.files[:clean].length).to eql(29)
+      if CI_ENV
         expect(PuppetCheck.files[:ignored].length).to eql(8)
       else
         expect(PuppetCheck.files[:ignored].length).to eql(7)
@@ -40,7 +40,7 @@ describe PuppetCheck::CLI do
     end
 
     it 'correctly loads a .puppet-lint.rc' do
-      expect(PuppetCheck::CLI.send(:parse, %W[-c #{fixtures_dir}/manifests/.puppet-lint.rc])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
+      expect(PuppetCheck::CLI.send(:parse, %W[-c #{FIXTURES_DIR}/manifests/.puppet-lint.rc])).to include(puppetlint_args: ['--puppetlint-arg-one', '--puppetlint-arg-two'])
     end
 
     it 'correctly parses Rubocop arguments' do

data/spec/puppet-check/data_parser_spec.rb

@@ -13,24 +13,24 @@ describe DataParser do
 
   context '.yaml' do
     it 'puts a bad syntax yaml file in the error files hash' do
-      DataParser.yaml(["#{fixtures_dir}hieradata/syntax.yaml"])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.yaml"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(/^block sequence entries are not allowed/)
+      DataParser.yaml(["#{FIXTURES_DIR}hieradata/syntax.yaml"])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}hieradata/syntax.yaml"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}hieradata/syntax.yaml"].join("\n")).to match(/^block sequence entries are not allowed/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good yaml file with potential hiera issues in the warning files array' do
-      DataParser.yaml(["#{fixtures_dir}hieradata/style.yaml"])
+      DataParser.yaml(["#{FIXTURES_DIR}hieradata/style.yaml"])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}hieradata/style.yaml"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}hieradata/style.yaml"].join("\n")).to match(/^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}hieradata/style.yaml"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}hieradata/style.yaml"].join("\n")).to match(/^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good yaml file in the clean files array' do
-      DataParser.yaml(["#{fixtures_dir}hieradata/good.yaml"])
+      DataParser.yaml(["#{FIXTURES_DIR}hieradata/good.yaml"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.yaml"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}hieradata/good.yaml"])
     end
   end
 
@@ -42,83 +42,83 @@ describe DataParser do
       expect { DataParser.eyaml(['foo.eyaml'], 'public.pem', nil) }.to output("Public X509 and/or Private RSA PKCS7 certs were not specified. EYAML checks will not be executed.\n").to_stderr
     end
     it 'returns a warning if the public key or private key are not existing files' do
-      expect { DataParser.eyaml(['foo.eyaml'], 'public.pem', 'private.pem') }.to output("Specified Public X509 and/or Private RSA PKCS7 certs do not exist. EYAML checks will not be executed.\n").to_stderr
+      expect { DataParser.eyaml(['foo.eyaml'], 'public.pem', 'private.pem') }.to output("Specified Public X509 and/or Private RSA PKCS7 certs do not exist or are not readable. EYAML checks will not be executed.\n").to_stderr
     end
     it 'puts a bad syntax eyaml file in the error files hash' do
-      DataParser.eyaml(["#{fixtures_dir}hieradata/syntax.eyaml"], "#{fixtures_dir}keys/public_key.pkcs7.pem", "#{fixtures_dir}keys/private_key.pkcs7.pem")
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.eyaml"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.eyaml"].join("\n")).to match(/^block sequence entries are not allowed/)
+      DataParser.eyaml(["#{FIXTURES_DIR}hieradata/syntax.eyaml"], "#{FIXTURES_DIR}keys/public_key.pkcs7.pem", "#{FIXTURES_DIR}keys/private_key.pkcs7.pem")
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}hieradata/syntax.eyaml"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}hieradata/syntax.eyaml"].join("\n")).to match(/^block sequence entries are not allowed/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good eyaml file with potential hiera issues in the warning files array' do
-      DataParser.eyaml(["#{fixtures_dir}hieradata/style.eyaml"], "#{fixtures_dir}keys/public_key.pkcs7.pem", "#{fixtures_dir}keys/private_key.pkcs7.pem")
+      DataParser.eyaml(["#{FIXTURES_DIR}hieradata/style.eyaml"], "#{FIXTURES_DIR}keys/public_key.pkcs7.pem", "#{FIXTURES_DIR}keys/private_key.pkcs7.pem")
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}hieradata/style.eyaml"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}hieradata/style.eyaml"].join("\n")).to match(/^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}hieradata/style.eyaml"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}hieradata/style.eyaml"].join("\n")).to match(/^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera may fail to parse it correctly/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good eyaml file in the clean files array' do
-      DataParser.eyaml(["#{fixtures_dir}hieradata/good.eyaml"], "#{fixtures_dir}keys/public_key.pkcs7.pem", "#{fixtures_dir}keys/private_key.pkcs7.pem")
+      DataParser.eyaml(["#{FIXTURES_DIR}hieradata/good.eyaml"], "#{FIXTURES_DIR}keys/public_key.pkcs7.pem", "#{FIXTURES_DIR}keys/private_key.pkcs7.pem")
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.eyaml"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}hieradata/good.eyaml"])
     end
   end
 
   context '.json' do
     it 'puts a bad syntax json file in the error files hash' do
-      DataParser.json(["#{fixtures_dir}hieradata/syntax.json"])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}hieradata/syntax.json"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.json"].join("\n")).to match(/after object value, got.*at line 2 column 3/)
+      DataParser.json(["#{FIXTURES_DIR}hieradata/syntax.json"])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}hieradata/syntax.json"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}hieradata/syntax.json"].join("\n")).to match(/after object value, got.*at line 2 column 3/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad metadata json file in the error files hash' do
-      DataParser.json(["#{fixtures_dir}metadata_syntax/metadata.json"])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}metadata_syntax/metadata.json"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}metadata_syntax/metadata.json"].join("\n")).to match(/^Required field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds/)
+      DataParser.json(["#{FIXTURES_DIR}metadata_syntax/metadata.json"])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}metadata_syntax/metadata.json"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}metadata_syntax/metadata.json"].join("\n")).to match(/^Required field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style metadata json file in the warning files array' do
-      DataParser.json(["#{fixtures_dir}metadata_style/metadata.json"])
+      DataParser.json(["#{FIXTURES_DIR}metadata_style/metadata.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}metadata_style/metadata.json"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}metadata_style/metadata.json"].join("\n")).to match(/^'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}metadata_style/metadata.json"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}metadata_style/metadata.json"].join("\n")).to match(/^'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts another bad style metadata json file in the warning files array' do
-      DataParser.json(["#{fixtures_dir}metadata_style_two/metadata.json"])
+      DataParser.json(["#{FIXTURES_DIR}metadata_style_two/metadata.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}metadata_style_two/metadata.json"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}metadata_style_two/metadata.json"].join("\n")).to match(%r{^'puppetlabs/one' has non-semantic versioning.*\n'puppetlabs/two' is missing an upper bound\.\n.*operatingsystem.*\n.*operatingsystemrelease})
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}metadata_style_two/metadata.json"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}metadata_style_two/metadata.json"].join("\n")).to match(%r{^'puppetlabs/one' has non-semantic versioning.*\n'puppetlabs/two' is missing an upper bound\.\n.*operatingsystem.*\n.*operatingsystemrelease})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad task metadata json file in the warning files array' do
-      DataParser.json(["#{fixtures_dir}task_metadata/task_bad.json"])
+      DataParser.json(["#{FIXTURES_DIR}task_metadata/task_bad.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}task_metadata/task_bad.json"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}task_metadata/task_bad.json"].join("\n")).to match(/^description value is not a String\ninput_method value is not one of environment, stdin, or powershell\nparameters value is not a Hash\npuppet_task_version value is not an Integer\nsupports_noop value is not a Boolean/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}task_metadata/task_bad.json"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}task_metadata/task_bad.json"].join("\n")).to match(/^description value is not a String\ninput_method value is not one of environment, stdin, or powershell\nparameters value is not a Hash\npuppet_task_version value is not an Integer\nsupports_noop value is not a Boolean/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good json file in the clean files array' do
-      DataParser.json(["#{fixtures_dir}hieradata/good.json"])
+      DataParser.json(["#{FIXTURES_DIR}hieradata/good.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}hieradata/good.json"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}hieradata/good.json"])
     end
     it 'puts a good metadata json file in the clean files array' do
-      DataParser.json(["#{fixtures_dir}metadata_good/metadata.json"])
+      DataParser.json(["#{FIXTURES_DIR}metadata_good/metadata.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}metadata_good/metadata.json"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}metadata_good/metadata.json"])
     end
     it 'puts a good task metadata json file in the clean files array' do
-      DataParser.json(["#{fixtures_dir}task_metadata/task_good.json"])
+      DataParser.json(["#{FIXTURES_DIR}task_metadata/task_good.json"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}task_metadata/task_good.json"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}task_metadata/task_good.json"])
     end
   end
 end

data/spec/puppet-check/puppet_parser_spec.rb

@@ -13,12 +13,12 @@ describe PuppetParser do
 
   context '.manifest' do
     it 'puts a bad syntax Puppet manifest in the error files hash' do
-      PuppetParser.manifest(["#{fixtures_dir}manifests/syntax.pp"], false, [])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}manifests/syntax.pp"])
+      PuppetParser.manifest(["#{FIXTURES_DIR}manifests/syntax.pp"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}manifests/syntax.pp"])
       if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('6.5.0')
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}manifests/syntax.pp"].join("\n")).to match(/^Language validation logged 2 errors/)
+        expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}manifests/syntax.pp"].join("\n")).to match(/^Language validation logged 2 errors/)
       else
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].join("\n")).to match(/^This Variable has no effect.*\nIllegal variable name/)
+        expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}manifests/syntax.pp"].join("\n")).to match(/^This Variable has no effect.*\nIllegal variable name/)
       end
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
@@ -26,77 +26,77 @@ describe PuppetParser do
     # puppet 5 api has output issues for this fixture
     unless Gem::Version.new(Puppet::PUPPETVERSION) < Gem::Version.new('6.0.0')
       it 'puts a bad syntax at eof Puppet manifest in the error files hash' do
-        PuppetParser.manifest(["#{fixtures_dir}manifests/eof_syntax.pp"], false, [])
-        expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}manifests/eof_syntax.pp"])
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}manifests/eof_syntax.pp"].join("\n")).to match(/^Syntax error at end of input/)
+        PuppetParser.manifest(["#{FIXTURES_DIR}manifests/eof_syntax.pp"], false, [])
+        expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}manifests/eof_syntax.pp"])
+        expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}manifests/eof_syntax.pp"].join("\n")).to match(/^Syntax error at end of input/)
         expect(PuppetCheck.files[:warnings]).to eql({})
         expect(PuppetCheck.files[:clean]).to eql([])
       end
     end
     it 'puts a bad syntax Puppet plan in the error files hash' do
-      PuppetParser.manifest(["#{fixtures_dir}plans/syntax.pp"], false, [])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}plans/syntax.pp"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}plans/syntax.pp"].join("\n")).to match(/^Syntax error at '\)'/)
+      PuppetParser.manifest(["#{FIXTURES_DIR}plans/syntax.pp"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}plans/syntax.pp"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}plans/syntax.pp"].join("\n")).to match(/^Syntax error at '\)'/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad parser style and lint style Puppet manifest in the warning files array' do
-      PuppetParser.manifest(["#{fixtures_dir}manifests/style_parser.pp"], true, [])
+      PuppetParser.manifest(["#{FIXTURES_DIR}manifests/style_parser.pp"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}manifests/style_parser.pp"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}manifests/style_parser.pp"].join("\n")).to match(/^Unrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}manifests/style_parser.pp"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}manifests/style_parser.pp"].join("\n")).to match(/^Unrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad lint style Puppet manifest in the warning files array' do
-      PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, [])
+      PuppetParser.manifest(["#{FIXTURES_DIR}manifests/style_lint.pp"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}manifests/style_lint.pp"].join("\n")).to match(/(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}manifests/style_lint.pp"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}manifests/style_lint.pp"].join("\n")).to match(/(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style Puppet manifest in the clean files array when puppetlint_args ignores its warnings' do
-      PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, ['--no-double_quoted_strings-check', '--no-arrow_alignment-check'])
+      PuppetParser.manifest(["#{FIXTURES_DIR}manifests/style_lint.pp"], true, ['--no-double_quoted_strings-check', '--no-arrow_alignment-check'])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}manifests/style_lint.pp"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}manifests/style_lint.pp"])
     end
     it 'puts a bad style Puppet plan in the warning files array' do
-      PuppetParser.manifest(["#{fixtures_dir}plans/style.pp"], true, [])
+      PuppetParser.manifest(["#{FIXTURES_DIR}plans/style.pp"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}plans/style.pp"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}plans/style.pp"].join("\n")).to match(/variable not enclosed in {}/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}plans/style.pp"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}plans/style.pp"].join("\n")).to match(/variable not enclosed in {}/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good Puppet manifest in the clean files array' do
-      PuppetParser.manifest(["#{fixtures_dir}manifests/good.pp"], true, [])
+      PuppetParser.manifest(["#{FIXTURES_DIR}manifests/good.pp"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}manifests/good.pp"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}manifests/good.pp"])
     end
     it 'puts a good Puppet plan in the clean files array' do
-      PuppetParser.manifest(["#{fixtures_dir}plans/good.pp"], true, [])
+      PuppetParser.manifest(["#{FIXTURES_DIR}plans/good.pp"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}plans/good.pp"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}plans/good.pp"])
     end
     it 'throws a well specified error for an invalid PuppetLint argument' do
-      expect { PuppetParser.manifest(["#{fixtures_dir}manifests/style_lint.pp"], true, ['--non-existent', '--does-not-exist']) }.to raise_error(RuntimeError, 'puppet-lint: invalid option supplied among --non-existent --does-not-exist')
+      expect { PuppetParser.manifest(["#{FIXTURES_DIR}manifests/style_lint.pp"], true, ['--non-existent', '--does-not-exist']) }.to raise_error(RuntimeError, 'puppet-lint: invalid option supplied among --non-existent --does-not-exist')
     end
   end
 
   context '.template' do
     it 'puts a bad syntax Puppet template in the error files hash' do
-      PuppetParser.template(["#{fixtures_dir}templates/syntax.epp"])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}templates/syntax.epp"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.epp"].join("\n")).to match(/^This Name has no effect/)
+      PuppetParser.template(["#{FIXTURES_DIR}templates/syntax.epp"])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}templates/syntax.epp"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}templates/syntax.epp"].join("\n")).to match(/^This Name has no effect/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a good Puppet template in the clean files array' do
-      PuppetParser.template(["#{fixtures_dir}templates/good.epp"])
+      PuppetParser.template(["#{FIXTURES_DIR}templates/good.epp"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}templates/good.epp"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}templates/good.epp"])
     end
   end
 end

data/spec/puppet-check/regression_check_spec.rb

@@ -7,10 +7,10 @@ begin
     context '.config' do
       # json gem is messed up for the EOL Ruby versions
       it 'raise an appropriate error if the file is malformed' do
-        expect { RegressionCheck.send(:config, "#{fixtures_dir}metadata.json") }.to raise_error(OctocatalogDiff::Errors::ConfigurationFileContentError, 'Configuration must define OctocatalogDiff::Config!')
+        expect { RegressionCheck.send(:config, "#{FIXTURES_DIR}metadata.json") }.to raise_error(OctocatalogDiff::Errors::ConfigurationFileContentError, 'Configuration must define OctocatalogDiff::Config!')
       end
       it 'loads in a good octocatalog-diff config file' do
-        expect { RegressionCheck.send(:config, "#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
+        expect { RegressionCheck.send(:config, "#{OCTOCATALOG_DIFF_DIR}octocatalog_diff.cfg.rb") }.not_to raise_exception
       end
       it 'loads in the settings from the file correctly' do
         # TODO
@@ -19,16 +19,16 @@ begin
 
     context '.smoke' do
       # octocatalog-diff is returning a blank error for these tests
-      unless ci_env
+      unless CI_ENV
         it 'returns a pass for a successful catalog compilation' do
-          expect { RegressionCheck.smoke(['good.example.com'], "#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
+          expect { RegressionCheck.smoke(['good.example.com'], "#{OCTOCATALOG_DIFF_DIR}octocatalog_diff.cfg.rb") }.not_to raise_exception
         end
         it 'returns a failure for a catalog with an error' do
-          expect { RegressionCheck.smoke(['does_not_exist.example.com'], "#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.to raise_error(OctocatalogDiff::Errors::CatalogError)
+          expect { RegressionCheck.smoke(['does_not_exist.example.com'], "#{OCTOCATALOG_DIFF_DIR}octocatalog_diff.cfg.rb") }.to raise_error(OctocatalogDiff::Errors::CatalogError)
         end
       end
       it 'returns a failure for a good and bad catalog' do
-        # RegressionCheck.smoke(['good.example.com', 'syntax_error.example.com'], "#{fixtures_dir}octocatalog_diff.cfg.rb")
+        # RegressionCheck.smoke(['good.example.com', 'syntax_error.example.com'], "#{FIXTURES_DIR}octocatalog_diff.cfg.rb")
       end
     end
 

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -5,17 +5,17 @@ require 'fileutils'
 describe RSpecPuppetSupport do
   after(:all) do
     # cleanup rspec_puppet_setup
-    File.delete("#{fixtures_dir}/spec/spec_helper.rb")
-    %w[manifests modules].each { |dir| FileUtils.rm_r("#{fixtures_dir}/spec/fixtures/#{dir}") }
+    File.delete("#{FIXTURES_DIR}/spec/spec_helper.rb")
+    %w[manifests modules].each { |dir| FileUtils.rm_r("#{FIXTURES_DIR}/spec/fixtures/#{dir}") }
   end
 
   context '.run' do
     let(:rspec_puppet_setup) { RSpecPuppetSupport.run }
-    before(:each) { Dir.chdir(fixtures_dir) }
+    before(:each) { Dir.chdir(FIXTURES_DIR) }
 
     it 'creates missing directories, missing site.pp, missing symlinks, and a missing spec_helper' do
       # circle ci and gh actions
-      if ci_env
+      if CI_ENV
         expect { rspec_puppet_setup }.to output("git is not installed and cannot be used to retrieve dependency modules\nsubversion is not installed and cannot be used to retrieve dependency modules\npuppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
       else
         expect { rspec_puppet_setup }.to output("subversion is not installed and cannot be used to retrieve dependency modules\npuppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
@@ -29,7 +29,7 @@ describe RSpecPuppetSupport do
       expect(File.file?('spec/spec_helper.rb')).to be true
 
       # .dependency_setup
-      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless ci_env
+      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless CI_ENV
       expect(File.directory?('spec/fixtures/modules/stdlib')).to be true
     end
   end

data/spec/puppet-check/ruby_parser_spec.rb

@@ -13,96 +13,96 @@ describe RubyParser do
 
   context '.ruby' do
     it 'puts a bad syntax ruby file in the error files hash' do
-      RubyParser.ruby(["#{fixtures_dir}lib/syntax.rb"], false, [])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}lib/syntax.rb"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}lib/syntax.rb"].join("\n")).to match(/^.*syntax error/)
+      RubyParser.ruby(["#{FIXTURES_DIR}lib/syntax.rb"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}lib/syntax.rb"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}lib/syntax.rb"].join("\n")).to match(/^.*syntax error/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style ruby file in the warning files array' do
-      RubyParser.ruby(["#{fixtures_dir}lib/style.rb"], true, [])
+      RubyParser.ruby(["#{FIXTURES_DIR}lib/style.rb"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}lib/style.rb"])
-      unless ci_env
-        expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(/Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}lib/style.rb"])
+      unless CI_ENV
+        expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}lib/style.rb"].length).to eql(8)
       else
-        expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(/Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty/)
+        expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}lib/style.rb"].join("\n")).to match(/Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Remove unnecessary empty.*\n.*Source code comment is empty/)
       end
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style ruby file in the clean files array when rubocop_args ignores its warnings' do
-      RubyParser.ruby(["#{fixtures_dir}lib/rubocop_style.rb"], true, ['--except', 'Lint/UselessAssignment,Style/HashSyntax,Style/GlobalVars,Style/StringLiterals'])
+      RubyParser.ruby(["#{FIXTURES_DIR}lib/rubocop_style.rb"], true, ['--except', 'Lint/UselessAssignment,Style/HashSyntax,Style/GlobalVars,Style/StringLiterals'])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}lib/rubocop_style.rb"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}lib/rubocop_style.rb"])
     end
     it 'puts a good ruby file in the clean files array' do
-      RubyParser.ruby(["#{fixtures_dir}lib/good.rb"], true, [])
+      RubyParser.ruby(["#{FIXTURES_DIR}lib/good.rb"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}lib/good.rb"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}lib/good.rb"])
     end
   end
 
   context '.template' do
     it 'puts a bad syntax ruby template file in the error files hash' do
-      RubyParser.template(["#{fixtures_dir}templates/syntax.erb"])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}templates/syntax.erb"])
+      RubyParser.template(["#{FIXTURES_DIR}templates/syntax.erb"])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}templates/syntax.erb"])
       if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(/1: syntax error, unexpected.*\n.*ruby/)
+        expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}templates/syntax.erb"].join("\n")).to match(/1: syntax error, unexpected.*\n.*ruby/)
       else
-        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(/syntax error, unexpected tIDENTIFIER/)
+        expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}templates/syntax.erb"].join("\n")).to match(/syntax error, unexpected tIDENTIFIER/)
       end
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style ruby template file in the warning files array' do
-      RubyParser.template(["#{fixtures_dir}templates/style.erb"])
+      RubyParser.template(["#{FIXTURES_DIR}templates/style.erb"])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}templates/style.erb"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}templates/style.erb"].join("\n")).to match(/already initialized constant.*\n.*previous definition of/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}templates/style.erb"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}templates/style.erb"].join("\n")).to match(/already initialized constant.*\n.*previous definition of/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a ruby template file with ignored errors in the clean files array' do
-      RubyParser.template(["#{fixtures_dir}templates/no_method_error.erb"])
+      RubyParser.template(["#{FIXTURES_DIR}templates/no_method_error.erb"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}templates/no_method_error.erb"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}templates/no_method_error.erb"])
     end
     it 'puts a good ruby template file in the clean files array' do
-      RubyParser.template(["#{fixtures_dir}templates/good.erb"])
+      RubyParser.template(["#{FIXTURES_DIR}templates/good.erb"])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}templates/good.erb"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}templates/good.erb"])
     end
   end
 
   context '.librarian' do
     it 'puts a bad syntax librarian Puppet file in the error files hash' do
-      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_syntax"], false, [])
-      expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}librarian/Puppetfile_syntax"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}librarian/Puppetfile_syntax"].join("\n")).to match(/^.*syntax error/)
+      RubyParser.librarian(["#{FIXTURES_DIR}librarian/Puppetfile_syntax"], false, [])
+      expect(PuppetCheck.files[:errors].keys).to eql(["#{FIXTURES_DIR}librarian/Puppetfile_syntax"])
+      expect(PuppetCheck.files[:errors]["#{FIXTURES_DIR}librarian/Puppetfile_syntax"].join("\n")).to match(/^.*syntax error/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style librarian Puppet file in the warning files array' do
-      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_style"], true, [])
+      RubyParser.librarian(["#{FIXTURES_DIR}librarian/Puppetfile_style"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
-      expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}librarian/Puppetfile_style"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}librarian/Puppetfile_style"].join("\n")).to match(/Align the arguments.*\n.*Use the new/)
+      expect(PuppetCheck.files[:warnings].keys).to eql(["#{FIXTURES_DIR}librarian/Puppetfile_style"])
+      expect(PuppetCheck.files[:warnings]["#{FIXTURES_DIR}librarian/Puppetfile_style"].join("\n")).to match(/Align the arguments.*\n.*Use the new/)
       expect(PuppetCheck.files[:clean]).to eql([])
     end
     it 'puts a bad style librarian Puppet file in the clean files array when rubocop_args ignores its warnings' do
-      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_style"], true, ['--except', 'Layout/ArgumentAlignment,Style/HashSyntax'])
+      RubyParser.librarian(["#{FIXTURES_DIR}librarian/Puppetfile_style"], true, ['--except', 'Layout/ArgumentAlignment,Style/HashSyntax'])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian/Puppetfile_style"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}librarian/Puppetfile_style"])
     end
     it 'puts a good librarian Puppet file in the clean files array' do
-      RubyParser.librarian(["#{fixtures_dir}librarian/Puppetfile_good"], true, [])
+      RubyParser.librarian(["#{FIXTURES_DIR}librarian/Puppetfile_good"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings]).to eql({})
-      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian/Puppetfile_good"])
+      expect(PuppetCheck.files[:clean]).to eql(["#{FIXTURES_DIR}librarian/Puppetfile_good"])
     end
   end
 end

data/spec/puppet-check/tasks_spec.rb

@@ -5,15 +5,15 @@ require_relative '../../lib/puppet-check/tasks'
 describe PuppetCheck::Tasks do
   after(:all) do
     # cleanup rspec_puppet_setup
-    File.delete("#{fixtures_dir}/spec/spec_helper.rb")
-    %w[manifests modules].each { |dir| FileUtils.rm_r("#{fixtures_dir}/spec/fixtures/#{dir}") }
+    File.delete("#{FIXTURES_DIR}/spec/spec_helper.rb")
+    %w[manifests modules].each { |dir| FileUtils.rm_r("#{FIXTURES_DIR}/spec/fixtures/#{dir}") }
   end
 
   context 'puppetcheck:spec' do
     let(:spec_tasks) { Rake::Task[:'puppetcheck:spec'].invoke }
 
     it 'executes RSpec and RSpec-Puppet checks in the expected manner' do
-      Dir.chdir(fixtures_dir)
+      Dir.chdir(FIXTURES_DIR)
 
       # rspec task executed
       expect { spec_tasks }.to output(%r{spec/facter/facter_spec.rb}).to_stdout

data/spec/puppet_check_spec.rb

@@ -35,7 +35,7 @@ describe PuppetCheck do
     it 'returns defaults correctly' do
       expect(PuppetCheck.send(:defaults)).to eql(
         {
-          fail_on_warning: false,
+          fail_on_warnings: false,
           style: false,
           smoke: false,
           regression: false,
@@ -52,7 +52,7 @@ describe PuppetCheck do
 
     it 'modifies settings correctly' do
       settings = {
-        fail_on_warning: true,
+        fail_on_warnings: true,
         style: true,
         smoke: true,
         regression: true,
@@ -69,9 +69,10 @@ describe PuppetCheck do
   end
 
   context '.parse_paths' do
-    before(:each) { Dir.chdir(fixtures_dir) }
+    before(:each) { Dir.chdir(FIXTURES_DIR) }
 
     let(:no_files) { PuppetCheck.send(:parse_paths, %w[foo bar baz]) }
+    let(:mixed_files) { PuppetCheck.send(:parse_paths, %w[foo lib/good.rb]) }
     let(:file) { PuppetCheck.send(:parse_paths, ['lib/good.rb']) }
     let(:dir) { PuppetCheck.send(:parse_paths, ['.']) }
     let(:multi_dir) { PuppetCheck.send(:parse_paths, %w[hieradata lib manifests]) }
@@ -81,13 +82,18 @@ describe PuppetCheck do
       expect { no_files }.to raise_error(RuntimeError, 'puppet-check: no files found in supplied paths \'foo, bar, baz\'.')
     end
 
+    it 'warns on invalid path and correctly parses a valid file path' do
+      expect { mixed_files }.to output("puppet-check: foo is not a readable directory, file, or symlink, and will not be considered during parsing\n").to_stderr
+      expect(mixed_files[0]).to eql('lib/good.rb')
+    end
+
     it 'correctly parses one file and returns it' do
       expect(file[0]).to eql('lib/good.rb')
     end
 
     it 'correctly parses one directory and returns all of its files' do
       dir.each { |file| expect(File.file?(file)).to be true }
-      if ci_env
+      if CI_ENV
         expect(dir.length).to eql(37)
       else
         expect(dir.length).to eql(40)

data/spec/spec_helper.rb

@@ -1,23 +1,10 @@
 require 'rspec'
 
 # for path to fixtures
-module Variables
-  extend RSpec::SharedContext
-
-  def fixtures_dir
-    @fixtures_dir = "#{File.dirname(__FILE__)}/fixtures/"
-  end
-
-  def octocatalog_diff_dir
-    @octocatalog_diff_dir = "#{File.dirname(__FILE__)}/octocatalog-diff/"
-  end
-
-  def ci_env
-    @ci_env = ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-  end
-end
+FIXTURES_DIR = "#{File.dirname(__FILE__)}/fixtures/".freeze
+OCTOCATALOG_DIFF_DIR = "#{File.dirname(__FILE__)}/octocatalog-diff/".freeze
+CI_ENV = ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
 
 RSpec.configure do |config|
-  config.include Variables
   config.color = true
 end

data/spec/system/system_spec.rb

@@ -6,10 +6,10 @@ require_relative '../../lib/puppet-check/tasks'
 describe PuppetCheck do
   context 'executed as a system from the CLI with arguments and various files to be processed' do
     it 'outputs diagnostic results correctly after processing all of the files' do
-      Dir.chdir(fixtures_dir)
+      Dir.chdir(FIXTURES_DIR)
 
       # see regression_check_spec
-      if ci_env
+      if CI_ENV
         expect(PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem .])).to eql(2)
       else
         expect(PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --public keys/public_key.pkcs7.pem --private keys/private_key.pkcs7.pem --smoke -n good.example.com --octoconfig spec/octocatalog-diff/octocatalog-diff.cfg.rb .])).to eql(2)
@@ -25,7 +25,7 @@ describe PuppetCheck do
   context 'executed as a system from the Rakefile with arguments and various files to be processed' do
     it 'outputs diagnostic results correctly after processing all of the files' do
       # ensure rake only checks the files inside fixtures
-      Dir.chdir(fixtures_dir)
+      Dir.chdir(FIXTURES_DIR)
 
       # clear out files member from previous system test
       PuppetCheck.files = {
@@ -47,7 +47,7 @@ describe PuppetCheck do
 
     it 'uses override settings and outputs diagnostic results correctly after processing all of the files' do
         # ensure rake only checks the files inside fixtures
-        Dir.chdir(fixtures_dir)
+        Dir.chdir(FIXTURES_DIR)
 
         # clear out files member from previous system test
         PuppetCheck.files = {
@@ -60,7 +60,7 @@ describe PuppetCheck do
         # assign settings
         settings = { style: true }
         # see regression_check_spec
-        unless ci_env
+        unless CI_ENV
           settings[:smoke] = true
           settings[:octonodes] = %w[good.example.com]
           settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-check
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Matt Schuchard
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-18 00:00:00.000000000 Z
+date: 2026-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: reek
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +221,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="