puppet-check 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a0fcb7ee7b05692747da7d0449b6bd442c3078311c0bcbd2e25bd56e491decd
-  data.tar.gz: 6ef3744b4c7a008c2a3042fd41b9bddc5f3dd236322180a8ff8cbc51df870b87
+  metadata.gz: a3c5911fe2362e7462d111f97705eea6b60842ce107bb94d35e6f8657cea6812
+  data.tar.gz: 52413822ec2375afd5fab3bb933220ad15bbcab285641f6717d94057c7fe0554
 SHA512:
-  metadata.gz: 8bdf3f7e6ba85fa4917329314f7f87382940b5e039a49891eb8d789aa57861d0e91b9f63b0d2a738523ffe1fb056e30842005d0f1bc06312859420ac9df1986e
-  data.tar.gz: 01f4cd1102f300ffa35b4943c8426b2e91db54b68bfb439489b4f88efce58248abd8839d738681cc2f6c2d55c46241aed13ff455cc2eb059374b3c6589c137b5
+  metadata.gz: fa0c790ee8186c5d1f2eb7091c78d789c68fef7d16292fe3a70c3d41a41d1eb65c3ece36462578bfe2874bb236316fa9b5737f7316f6902d1017bb15c182cf0a
+  data.tar.gz: 87e82df7685a13f4122838b225ef8e44d8de30b9e14f8cbb75577b76074fff5f40ca895c7bef00a7648862abba1edc31d5e237b0cb4ba8e0e5e1eb5aa4486304

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+### 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.

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.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.5.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'

data/spec/puppet-check/cli_spec.rb

@@ -6,7 +6,7 @@ describe PuppetCheck::CLI 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(29)
-      if ci_env
+      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"].length).to eql(8)
+      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,7 +69,7 @@ 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]) }
@@ -83,7 +83,7 @@ describe PuppetCheck do
     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 directory, file, or symlink, and will not be considered during parsing\n").to_stderr
+      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
 
@@ -93,7 +93,7 @@ describe PuppetCheck do
 
     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.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Matt Schuchard
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet