puppet-check 2.2.2 → 2.3.1

data/lib/puppet_check.rb

@@ -13,7 +13,7 @@ class PuppetCheck
     ignored: []
   }
 
-  # allow the parser methods write to the files
+  # allow the parser methods to write to the files
   class << self
     attr_accessor :files
   end
@@ -27,7 +27,7 @@ class PuppetCheck
     files = self.class.parse_paths(paths)
 
     # parse the files
-    parsed_files = execute_parsers(files, settings)
+    parsed_files = execute_parsers(files, settings[:style], settings[:puppetlint_args], settings[:rubocop_args], settings[:public], settings[:private])
 
     # output the diagnostic results
     OutputResults.run(parsed_files.clone, settings[:output_format])
@@ -36,14 +36,12 @@ class PuppetCheck
     if parsed_files[:errors].empty? && (!settings[:fail_on_warning] || parsed_files[:warnings].empty?)
       begin
         require_relative 'puppet-check/regression_check'
-      # if octocatalog-diff is not installed then return immediately
-      rescue LoadError
-        return 0
-      end
 
-      # perform smoke checks if there were no errors and the user desires
-      begin
+        # perform smoke checks if there were no errors and the user desires
         catalog = RegressionCheck.smoke(settings[:octonodes], settings[:octoconfig]) if settings[:smoke]
+      # if octocatalog-diff is not installed then continue immediately
+      rescue NameError
+        puts 'puppet-check: immediately continuing to results'
       # smoke check failure? output message and return 2
       rescue OctocatalogDiff::Errors::CatalogError => err
         puts 'There was a smoke check error:'
@@ -60,6 +58,7 @@ class PuppetCheck
       #   puts catalog.error_message unless catalog.valid?
       #   2
       # end
+
       # code to output differences in catalog?
       # everything passed? return 0
       0
@@ -72,29 +71,26 @@ class PuppetCheck
   # establish default settings
   def self.defaults(settings = {})
     private_class_method :method
-    # initialize fail on warning,  style check, and regression check bools
-    settings[:fail_on_warning] ||= false
-    settings[:style] ||= false
-    settings[:smoke] ||= false
-    settings[:regression] ||= false
-
-    # initialize ssl keys for eyaml checks
-    settings[:public] ||= nil
-    settings[:private] ||= nil
 
-    # initialize output format option
-    settings[:output_format] ||= 'text'
-
-    # initialize octocatalog-diff options
-    settings[:octoconfig] ||= '.octocatalog-diff.cfg.rb'
-    settings[:octonodes] ||= %w[localhost.localdomain]
-
-    # initialize style arg arrays
-    settings[:puppetlint_args] ||= []
-    settings[:rubocop_args] ||= []
-
-    # return update settings
-    settings
+    # return settings with defaults where unspecified
+    {
+      # initialize fail on warning,  style check, and regression check bools
+      fail_on_warning: false,
+      style: false,
+      smoke: false,
+      regression: false,
+      # initialize ssl keys for eyaml checks
+      public: nil,
+      private: nil,
+      # initialize output format option
+      output_format: 'text',
+      # initialize octocatalog-diff options
+      octoconfig: '.octocatalog-diff.cfg.rb',
+      octonodes: %w[localhost.localdomain],
+      # initialize style arg arrays
+      puppetlint_args: [],
+      rubocop_args: []
+    }.merge(settings)
   end
 
   # parse the paths and return the array of files
@@ -102,36 +98,36 @@ class PuppetCheck
     private_class_method :method
     files = []
 
-    # traverse the unique paths and return all files
+    # traverse the unique paths and return all files not explicitly in fixtures
     paths.uniq.each do |path|
       if File.directory?(path)
-        files.concat(Dir.glob("#{path}/**/*").select { |subpath| File.file?(subpath) })
-      elsif File.file?(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.push(path)
+      else
+        warn "puppet-check: #{path} is not a directory, file, or symlink, and will not be considered during parsing"
       end
     end
 
-    # do not process fixtures, check that at least one file was found, and remove double slashes
-    files.reject! { |file| file.include?('fixtures') }
+    # check that at least one file was found, and remove double slashes from returned array
     raise "puppet-check: no files found in supplied paths '#{paths.join(', ')}'." if files.empty?
-    files.map! { |file| file.gsub('//', '/') }
-
-    files.uniq
+    files.map { |file| file.gsub('//', '/') }.uniq
   end
 
   private
 
   # categorize and pass the files out to the parsers to determine their status
-  def execute_parsers(files, settings)
+  def execute_parsers(files, style, puppetlint_args, rubocop_args, public, private)
     # check manifests
     manifests, files = files.partition { |file| File.extname(file) == '.pp' }
-    PuppetParser.manifest(manifests, settings[:style], settings[:puppetlint_args]) unless manifests.empty?
+    PuppetParser.manifest(manifests, style, puppetlint_args) unless manifests.empty?
     # check puppet templates
     templates, files = files.partition { |file| File.extname(file) == '.epp' }
     PuppetParser.template(templates) unless templates.empty?
     # check ruby files
     rubies, files = files.partition { |file| File.extname(file) == '.rb' }
-    RubyParser.ruby(rubies, settings[:style], settings[:rubocop_args]) unless rubies.empty?
+    RubyParser.ruby(rubies, style, rubocop_args) unless rubies.empty?
     # check ruby templates
     templates, files = files.partition { |file| File.extname(file) == '.erb' }
     RubyParser.template(templates) unless templates.empty?
@@ -142,11 +138,11 @@ class PuppetCheck
     jsons, files = files.partition { |file| File.extname(file) == '.json' }
     DataParser.json(jsons) unless jsons.empty?
     # check eyaml data; block this for now
-    # eyamls, files = files.partition { |file| File.extname(file) =~ /\.eya?ml$/ }
-    # DataParser.eyaml(eyamls, public, private) unless eyamls.empty?
+    eyamls, files = files.partition { |file| File.extname(file) =~ /\.eya?ml$/ }
+    DataParser.eyaml(eyamls, public, private) unless eyamls.empty?
     # check misc ruby
-    librarians, files = files.partition { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem)file$/ }
-    RubyParser.librarian(librarians, settings[:style], settings[:rubocop_args]) unless librarians.empty?
+    librarians, files = files.partition { |file| File.basename(file) =~ /(?:Puppet|Module|Rake|Gem|Vagrant)file|.gemspec$/ }
+    RubyParser.librarian(librarians, style, rubocop_args) unless librarians.empty?
     # ignore everything else
     files.each { |file| self.class.files[:ignored].push(file.to_s) }
     # return PuppetCheck.files to mitigate singleton write accessor side effects

data/puppet-check.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'puppet-check'
+  spec.version       = '2.3.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'
+  spec.homepage      = 'https://www.github.com/mschuchard/puppet-check'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['bin/**/*', 'lib/**/*', 'spec/**/*', 'CHANGELOG.md', 'LICENSE.md', 'README.md', 'puppet-check.gemspec']
+  spec.executables   = spec.files.grep(%r{^bin/}) { |file| File.basename(file) }
+  spec.require_paths = Dir['lib']
+
+  spec.required_ruby_version = '>= 2.7.0'
+  spec.add_dependency 'puppet', '>= 5.5', '< 9'
+  spec.add_dependency 'puppet-lint', '~> 4.0'
+  spec.add_dependency 'reek', '~> 6.0'
+  spec.add_dependency 'rubocop', '~> 1.0'
+  spec.add_dependency 'rubocop-performance', '~> 1.0'
+  # spec.add_development_dependency 'octocatalog-diff', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/spec/octocatalog-diff/octocatalog_diff.cfg.rb

@@ -9,11 +9,7 @@ module OctocatalogDiff
       settings[:hiera_config] = "#{octocatalog_diff_dir}hiera.yaml"
       settings[:hiera_path] = "#{octocatalog_diff_dir}hieradata"
       settings[:fact_file] = "#{octocatalog_diff_dir}facts.yaml"
-      settings[:puppet_binary] = if ENV['TRAVIS'] == 'true'
-                                   "#{octocatalog_diff_dir}../../bin/puppet"
-                                 else
-                                   '/usr/local/bin/puppet'
-                                 end
+      settings[:puppet_binary] = '/usr/local/bin/puppet'
       settings[:bootstrapped_to_dir] = octocatalog_diff_dir
 
       settings

data/spec/puppet-check/cli_spec.rb

@@ -3,14 +3,16 @@ require_relative '../../lib/puppet-check/cli'
 
 describe PuppetCheck::CLI do
   context '.run' do
-    it 'raises an error if no paths were specified' do
-      expect { PuppetCheck::CLI.run(%w[-s -f]) }.to raise_error(RuntimeError, 'puppet-check: no file paths specified; try using --help')
+    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)
+      expect(PuppetCheck.files[:ignored].length).to eql(7)
     end
   end
 
   context '.parse' do
     it 'raises an error if an invalid option was specified' do
-      expect { PuppetCheck::CLI.parse(%w[-s -f -asdf foo]) }.to raise_error(OptionParser::InvalidOption)
+      expect { PuppetCheck::CLI.parse(%w[-s -asdf foo]) }.to raise_error(OptionParser::InvalidOption)
     end
 
     it 'allows fail on warnings, style, smoke, and regression checks to be enabled' do

data/spec/puppet-check/data_parser_spec.rb

@@ -15,7 +15,7 @@ describe DataParser 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(%r{^block sequence entries are not allowed})
+      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
@@ -23,7 +23,7 @@ describe DataParser do
       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(%r{^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]["#{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
@@ -45,23 +45,24 @@ describe DataParser 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
     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][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.eyaml:\nblock 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"]).to match(%r{^Value\(s\) missing in key.*\nValue\(s\) missing in key.*\nThe string --- appears more than once in this data and Hiera will 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
 
@@ -69,14 +70,14 @@ describe DataParser 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(%r{^.*unexpected token})
+      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(%r{^Required field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
+      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
@@ -84,7 +85,7 @@ describe DataParser do
       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(%r{^'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier})
+      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
@@ -98,7 +99,7 @@ describe DataParser do
       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(%r{^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]["#{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

data/spec/puppet-check/output_results_spec.rb

@@ -5,19 +5,19 @@ describe OutputResults do
   context '.text' do
     it 'outputs files with errors' do
       files = { errors: { 'foo' => ['i had an error'] } }
-      expect { OutputResults.text(files) }.to output("\033[31mThe following files have errors:\033[0m\n-- foo:\ni had an error\n").to_stdout
+      expect { OutputResults.text(files) }.to output("\033[31mThe following files have errors:\033[0m\n-- foo:\ni had an error\n\n").to_stdout
     end
     it 'outputs files with warnings' do
       files = { warnings: { 'foo' => ['i had a warning'] } }
-      expect { OutputResults.text(files) }.to output("\n\033[33mThe following files have warnings:\033[0m\n-- foo:\ni had a warning\n").to_stdout
+      expect { OutputResults.text(files) }.to output("\033[33mThe following files have warnings:\033[0m\n-- foo:\ni had a warning\n\n").to_stdout
     end
     it 'outputs files with no errors or warnings' do
       files = { clean: ['foo'] }
-      expect { OutputResults.text(files) }.to output("\n\033[32mThe following files have no errors or warnings:\033[0m\n-- foo\n").to_stdout
+      expect { OutputResults.text(files) }.to output("\033[32mThe following files have no errors or warnings:\033[0m\n-- foo\n\n").to_stdout
     end
     it 'outputs files that were not processed' do
       files = { ignored: ['foo'] }
-      expect { OutputResults.text(files) }.to output("\n\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo\n").to_stdout
+      expect { OutputResults.text(files) }.to output("\033[36mThe following files have unrecognized formats and therefore were not processed:\033[0m\n-- foo\n\n").to_stdout
     end
   end
 

data/spec/puppet-check/puppet_parser_spec.rb

@@ -16,9 +16,9 @@ describe PuppetParser do
       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(%r{^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(%r{^This Variable has no effect.*\nIllegal variable name})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}hieradata/syntax.yaml"].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([])
@@ -28,7 +28,7 @@ describe PuppetParser do
       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(%r{^Syntax error at end of input})
+        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
@@ -36,7 +36,7 @@ describe PuppetParser do
     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(%r{^Syntax error at '\)'})
+      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
@@ -44,14 +44,14 @@ describe PuppetParser do
       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(%r{^Unrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing})
+      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, [])
       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(%r{(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)})
+      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
@@ -64,7 +64,7 @@ describe PuppetParser do
       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(%r{variable not enclosed in {}})
+      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
@@ -88,7 +88,7 @@ describe PuppetParser 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(%r{^This Name has no effect})
+      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

data/spec/puppet-check/regression_check_spec.rb

@@ -1,35 +1,41 @@
 require_relative '../spec_helper'
-require_relative '../../lib/puppet-check/regression_check'
+begin
+  require_relative '../../lib/puppet-check/regression_check'
 
-# once a good config is loaded, bad configs would have no effect so failures are tested first; config is also tested before compilation so that the good config can be loaded at the end and used for compilation and regression tests
-describe RegressionCheck do
-  context '.config' do
-    # json gem got messed up for the EOL Ruby versions
-    it 'raise an appropriate error if the file is malformed' do
-      expect { RegressionCheck.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.config("#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
-    end
-    it 'loads in the settings from the file correctly' do
+  # once a good config is loaded, bad configs would have no effect so failures are tested first; config is also tested before compilation so that the good config can be loaded at the end and used for compilation and regression tests
+  describe RegressionCheck do
+    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.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.config("#{octocatalog_diff_dir}octocatalog_diff.cfg.rb") }.not_to raise_exception
+      end
+      it 'loads in the settings from the file correctly' do
+        # TODO
+      end
     end
-  end
 
-  context '.smoke' do
-    # octocatalog-diff is returning a blank error for these tests
-    unless ENV['TRAVIS'] == 'true' || ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-      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
+    context '.smoke' do
+      # octocatalog-diff is returning a blank error for these tests
+      unless ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+        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
+        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)
+        end
       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)
+      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")
       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")
-    end
-  end
 
-  context '.regression' do
+    context '.regression' do
+      # TODO
+    end
   end
+rescue NameError
+  puts 'puppet-check+rspec: octocatalog-diff is not installed, and its unit tests will be skipped'
 end

data/spec/puppet-check/rspec_puppet_support_spec.rb

@@ -14,11 +14,8 @@ describe RSpecPuppetSupport do
     before(:each) { Dir.chdir(fixtures_dir) }
 
     it 'creates missing directories, missing site.pp, missing symlinks, and a missing spec_helper' do
-      # travis ci
-      if ENV['TRAVIS'] == 'true'
-        expect { rspec_puppet_setup }.to output("puppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
       # circle ci and gh actions
-      elsif ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
         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

data/spec/puppet-check/ruby_parser_spec.rb

@@ -15,7 +15,7 @@ describe RubyParser 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(%r{^.*syntax error})
+      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
@@ -23,7 +23,7 @@ describe RubyParser do
       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"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}lib/style.rb"].join("\n")).to match(%r{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]["#{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[:clean]).to eql([])
     end
     it 'puts a bad style ruby file in the clean files array when rubocop_args ignores its warnings' do
@@ -45,9 +45,9 @@ describe RubyParser do
       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(%r{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(%r{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([])
@@ -56,7 +56,7 @@ describe RubyParser do
       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(%r{already initialized constant.*\n.*previous definition of})
+      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
@@ -77,7 +77,7 @@ describe RubyParser do
     it 'puts a bad syntax librarian Puppet file in the error files hash' do
       RubyParser.librarian(["#{fixtures_dir}librarian_syntax/Puppetfile"], false, [])
       expect(PuppetCheck.files[:errors].keys).to eql(["#{fixtures_dir}librarian_syntax/Puppetfile"])
-      expect(PuppetCheck.files[:errors]["#{fixtures_dir}librarian_syntax/Puppetfile"].join("\n")).to match(%r{^.*syntax error})
+      expect(PuppetCheck.files[:errors]["#{fixtures_dir}librarian_syntax/Puppetfile"].join("\n")).to match(/^.*syntax error/)
       expect(PuppetCheck.files[:warnings]).to eql({})
       expect(PuppetCheck.files[:clean]).to eql([])
     end
@@ -85,7 +85,7 @@ describe RubyParser do
       RubyParser.librarian(["#{fixtures_dir}librarian_style/Puppetfile"], true, [])
       expect(PuppetCheck.files[:errors]).to eql({})
       expect(PuppetCheck.files[:warnings].keys).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
-      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}librarian_style/Puppetfile"].join("\n")).to match(%r{Align the arguments.*\n.*Use the new})
+      expect(PuppetCheck.files[:warnings]["#{fixtures_dir}librarian_style/Puppetfile"].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

data/spec/puppet_check_spec.rb

@@ -87,7 +87,11 @@ 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 }
-      expect(dir.length).to eql(37)
+      if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+        expect(dir.length).to eql(37)
+      else
+        expect(dir.length).to eql(40)
+      end
     end
 
     it 'correctly parses multiple directories and returns all of their files' do

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
     # see regression_check_spec
-    if ENV['TRAVIS'] == 'true' || ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding .]) }
+    if ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      let(:cli) { 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 .]) }
     else
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Layout/LineLength,Style/Encoding --smoke -n good.example.com --octoconfig spec/octocatalog-diff/octocatalog-diff.cfg.rb .]) }
+      let(:cli) { 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 .]) }
     end
 
     it 'outputs diagnostic results correctly after processing all of the files' do
@@ -17,10 +17,10 @@ describe PuppetCheck do
 
       expect { cli }.not_to raise_exception
 
-      expect(PuppetCheck.files[:errors].length).to eql(10)
-      expect(PuppetCheck.files[:warnings].length).to eql(11)
-      expect(PuppetCheck.files[:clean].length).to eql(13)
-      expect(PuppetCheck.files[:ignored].length).to eql(6)
+      expect(PuppetCheck.files[:errors].length).to eql(11)
+      expect(PuppetCheck.files[:warnings].length).to eql(12)
+      expect(PuppetCheck.files[:clean].length).to eql(14)
+      expect(PuppetCheck.files[:ignored].length).to eql(3)
 
       expect(cli).to eql(2)
     end
@@ -40,7 +40,7 @@ describe PuppetCheck do
       }
       settings = { style: true }
       # see regression_check_spec
-      unless ENV['TRAVIS'] == 'true' || ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+      unless ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
         settings[:smoke] = true
         settings[:octonodes] = %w[good.example.com]
         settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'
@@ -50,10 +50,10 @@ describe PuppetCheck do
       expect { Rake::Task[:'puppetcheck:file'].invoke(settings) }.to raise_error(ArgumentError, /Attempt to redefine entity/)
 
       # current puppet pops limitations no longer allow testing this
-      # expect(PuppetCheck.files[:errors].length).to eql(10)
-      # expect(PuppetCheck.files[:warnings].length).to eql(11)
-      # expect(PuppetCheck.files[:clean].length).to eql(13)
-      # expect(PuppetCheck.files[:ignored].length).to eql(6)
+      # expect(PuppetCheck.files[:errors].length).to eql(11)
+      # expect(PuppetCheck.files[:warnings].length).to eql(12)
+      # expect(PuppetCheck.files[:clean].length).to eql(14)
+      # expect(PuppetCheck.files[:ignored].length).to eql(3)
     end
   end
 end