puppet-check 2.0.0 → 2.2.0

data/spec/puppet-check/data_parser_spec.rb

@@ -10,106 +10,104 @@ describe DataParser do
 
   context '.yaml' do
     it 'puts a bad syntax yaml file in the error files array' do
-      DataParser.yaml([fixtures_dir + 'hieradata/syntax.yaml'])
+      DataParser.yaml(["#{fixtures_dir}hieradata/syntax.yaml"])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.yaml:\nblock sequence entries are not allowed})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}hieradata/style.yaml:\nValue\(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.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.yaml"])
     end
   end
 
-  if RUBY_VERSION.to_f >= 2.3
-    context '.eyaml' do
-      before(:each) do
-        PuppetCheck.settings[:ignored_files] = []
-      end
+  context '.eyaml' do
+    before(:each) do
+      PuppetCheck.settings[:ignored_files] = []
+    end
 
-      it 'returns a warning if a public key was not specified' do
-        expect { DataParser.eyaml(['foo.eyaml'], nil, 'private.pem') }.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 a private key was not specified' 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
-      end
-      it 'puts a bad syntax eyaml file in the error files array' do
-        # DataParser.eyaml([fixtures_dir + 'hieradata/syntax.eyaml'], fixtures_dir + 'keys/public_key.pkcs7.pem', fixtures_dir + 'keys/private_key.pkcs7.pem')
-        # expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.eyaml:\nblock sequence entries are not allowed})
-        expect(PuppetCheck.settings[:warning_files]).to eql([])
-        expect(PuppetCheck.settings[:clean_files]).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')
-        expect(PuppetCheck.settings[:error_files]).to eql([])
-        # expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}hieradata/style.eyaml:\nValue\(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.settings[:clean_files]).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')
-        expect(PuppetCheck.settings[:error_files]).to eql([])
-        expect(PuppetCheck.settings[:warning_files]).to eql([])
-        # expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.eyaml"])
-      end
+    it 'returns a warning if a public key was not specified' do
+      expect { DataParser.eyaml(['foo.eyaml'], nil, 'private.pem') }.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 a private key was not specified' 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
+    end
+    it 'puts a bad syntax eyaml file in the error files array' do
+      # DataParser.eyaml(["#{fixtures_dir}hieradata/syntax.eyaml'], fixtures_dir + 'keys/public_key.pkcs7.pem', fixtures_dir + 'keys/private_key.pkcs7.pem")
+      # expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.eyaml:\nblock sequence entries are not allowed})
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).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")
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      # expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}hieradata/style.eyaml:\nValue\(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.settings[:clean_files]).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")
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      # expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}hieradata/good.eyaml"])
     end
   end
 
   context '.json' do
     it 'puts a bad syntax json file in the error files array' do
-      DataParser.json([fixtures_dir + 'hieradata/syntax.json'])
+      DataParser.json(["#{fixtures_dir}hieradata/syntax.json"])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}hieradata/syntax.json:\n.*unexpected token})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad metadata json file in the error files array' do
-      DataParser.json([fixtures_dir + 'metadata_syntax/metadata.json'])
+      DataParser.json(["#{fixtures_dir}metadata_syntax/metadata.json"])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}metadata_syntax/metadata.json:\nRequired field.*\nField 'requirements'.*\nDuplicate dependencies.*\nDeprecated field.*\nSummary exceeds})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}metadata_style/metadata.json:\n'pe' is missing an upper bound.\n.*operatingsystem_support.*\nLicense identifier})
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}metadata_style_two/metadata.json:\n'puppetlabs/one' has non-semantic versioning.*\n'puppetlabs/two' is missing an upper bound\.\n.*operatingsystem.*\n.*operatingsystemrelease})
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}task_metadata/task_bad.json:\ndescription 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.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}task_metadata/task_good.json"])

data/spec/puppet-check/output_results_spec.rb

@@ -38,38 +38,38 @@ describe OutputResults do
 
     it 'outputs files with errors as yaml' do
       PuppetCheck.settings[:error_files] = ['foo: i had an error']
-      expect { OutputResults.markup(output_format: 'yaml') }.to output("---\nerrors:\n- 'foo: i had an error'\n").to_stdout
+      expect { OutputResults.markup('yaml') }.to output("---\nerrors:\n- 'foo: i had an error'\n").to_stdout
     end
     it 'outputs files with warnings as yaml' do
       PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
-      expect { OutputResults.markup(output_format: 'yaml') }.to output("---\nwarnings:\n- 'foo: i had a warning'\n").to_stdout
+      expect { OutputResults.markup('yaml') }.to output("---\nwarnings:\n- 'foo: i had a warning'\n").to_stdout
     end
     it 'outputs files with no errors or warnings as yaml' do
       PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
-      expect { OutputResults.markup(output_format: 'yaml') }.to output("---\nclean:\n- 'foo: i was totally good to go'\n").to_stdout
+      expect { OutputResults.markup('yaml') }.to output("---\nclean:\n- 'foo: i was totally good to go'\n").to_stdout
     end
     it 'outputs files that were not processed as yaml' do
       PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
-      expect { OutputResults.markup(output_format: 'yaml') }.to output("---\nignored:\n- 'foo: who knows what i am'\n").to_stdout
+      expect { OutputResults.markup('yaml') }.to output("---\nignored:\n- 'foo: who knows what i am'\n").to_stdout
     end
     it 'outputs files with errors as json' do
       PuppetCheck.settings[:error_files] = ['foo: i had an error']
-      expect { OutputResults.markup(output_format: 'json') }.to output("{\n  \"errors\": [\n    \"foo: i had an error\"\n  ]\n}\n").to_stdout
+      expect { OutputResults.markup('json') }.to output("{\n  \"errors\": [\n    \"foo: i had an error\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files with warnings as json' do
       PuppetCheck.settings[:warning_files] = ['foo: i had a warning']
-      expect { OutputResults.markup(output_format: 'json') }.to output("{\n  \"warnings\": [\n    \"foo: i had a warning\"\n  ]\n}\n").to_stdout
+      expect { OutputResults.markup('json') }.to output("{\n  \"warnings\": [\n    \"foo: i had a warning\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files with no errors or warnings as json' do
       PuppetCheck.settings[:clean_files] = ['foo: i was totally good to go']
-      expect { OutputResults.markup(output_format: 'json') }.to output("{\n  \"clean\": [\n    \"foo: i was totally good to go\"\n  ]\n}\n").to_stdout
+      expect { OutputResults.markup('json') }.to output("{\n  \"clean\": [\n    \"foo: i was totally good to go\"\n  ]\n}\n").to_stdout
     end
     it 'outputs files that were not processed as json' do
       PuppetCheck.settings[:ignored_files] = ['foo: who knows what i am']
-      expect { OutputResults.markup(output_format: 'json') }.to output("{\n  \"ignored\": [\n    \"foo: who knows what i am\"\n  ]\n}\n").to_stdout
+      expect { OutputResults.markup('json') }.to output("{\n  \"ignored\": [\n    \"foo: who knows what i am\"\n  ]\n}\n").to_stdout
     end
     it 'raises an error for an unsupported output format' do
-      expect { OutputResults.markup(output_format: 'awesomesauce') }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
+      expect { OutputResults.markup('awesomesauce') }.to raise_error(RuntimeError, 'puppet-check: Unsupported output format \'awesomesauce\' was specified.')
     end
   end
 end

data/spec/puppet-check/puppet_parser_spec.rb

@@ -10,62 +10,80 @@ describe PuppetParser do
 
   context '.manifest' do
     it 'puts a bad syntax Puppet manifest in the error files array' do
-      PuppetParser.manifest([fixtures_dir + 'manifests/syntax.pp'], false, [])
-      if Puppet::PUPPETVERSION.to_f >= 6.5
+      PuppetParser.manifest(["#{fixtures_dir}manifests/syntax.pp"], false, [])
+      if Gem::Version.new(Puppet::PUPPETVERSION) >= Gem::Version.new('6.5.0')
         expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nLanguage validation logged 2 errors})
-      # dealing with annoying warning in puppet 5 and 6
-      elsif RUBY_VERSION.to_f < 2.3
-        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nSupport for ruby version.*\n.*\nThis Variable has no effect.*\nIllegal variable name})
       else
         expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/syntax.pp:\nThis Variable has no effect.*\nIllegal variable name})
       end
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
-    it 'puts a bad syntax at eof Puppet manifest in the error files array' do
-      PuppetParser.manifest([fixtures_dir + 'manifests/eof_syntax.pp'], false, [])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/eof_syntax.pp:\nSyntax error at end of input})
+    # 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 array' do
+        PuppetParser.manifest(["#{fixtures_dir}manifests/eof_syntax.pp"], false, [])
+        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}manifests/eof_syntax.pp:\nSyntax error at end of input})
+        expect(PuppetCheck.settings[:warning_files]).to eql([])
+        expect(PuppetCheck.settings[:clean_files]).to eql([])
+      end
+    end
+    it 'puts a bad syntax Puppet plan in the error files array' do
+      PuppetParser.manifest(["#{fixtures_dir}plans/syntax.pp"], false, [])
+      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}plans/syntax.pp:\nSyntax error at '\)'})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad parser 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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_parser.pp:\nUnrecognized escape sequence.*\nUnrecognized escape sequence.*\n.*double quoted string containing})
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_lint.pp:\n.*double quoted string containing.*\n.*indentation of})
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}manifests/style_lint.pp:\n.*(?:indentation of|double quoted string containing).*\n.*(?:indentation of|double quoted string containing)})
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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, [])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}plans/style.pp:\n.*variable not enclosed in {}})
+      expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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, [])
+      expect(PuppetCheck.settings[:error_files]).to eql([])
+      expect(PuppetCheck.settings[:warning_files]).to eql([])
+      expect(PuppetCheck.settings[:clean_files]).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 array' do
-      PuppetParser.template([fixtures_dir + 'templates/syntax.epp'])
+      PuppetParser.template(["#{fixtures_dir}templates/syntax.epp"])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.epp:\nThis Name has no effect})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}templates/good.epp"])

data/spec/puppet-check/regression_check_spec.rb

@@ -5,13 +5,11 @@ require_relative '../../lib/puppet-check/regression_check'
 describe RegressionCheck do
   context '.config' do
     # json gem got messed up for the EOL Ruby versions
-    if RUBY_VERSION.to_f >= 2.2
-      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 '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
+      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
     end
@@ -19,16 +17,16 @@ describe RegressionCheck do
 
   context '.smoke' do
     # octocatalog-diff is returning a blank error for these tests
-    unless File.directory?('/home/travis')
+    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
+        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

@@ -1,12 +1,12 @@
-require_relative '../spec_helper.rb'
+require_relative '../spec_helper'
 require_relative '../../lib/puppet-check/rspec_puppet_support'
 require 'fileutils'
 
 describe RSpecPuppetSupport do
   after(:all) do
     # cleanup rspec_puppet_setup
-    File.delete('spec/spec_helper.rb')
-    %w[manifests modules].each { |dir| FileUtils.rm_r('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
@@ -14,7 +14,15 @@ describe RSpecPuppetSupport do
     before(:each) { Dir.chdir(fixtures_dir) }
 
     it 'creates missing directories, missing site.pp, missing symlinks, and a missing spec_helper' do
-      expect { rspec_puppet_setup }.to output("puppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
+      # travis ci
+      if ENV['TRAVIS'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
+        expect { rspec_puppet_setup }.to output("puppetlabs/gruntmaster has an unspecified, or specified but unsupported, download method.\n").to_stderr
+      # circle ci
+      elsif ENV['CIRCLECI'] == '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
+      end
 
       # .file_setup
       expect(File.directory?('spec/fixtures/manifests')).to be true
@@ -24,7 +32,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
+      expect(File.directory?('spec/fixtures/modules/puppetlabs-lvm')).to be true unless ENV['CIRCLECI'] == 'true'
       expect(File.directory?('spec/fixtures/modules/stdlib')).to be true
     end
   end

data/spec/puppet-check/ruby_parser_spec.rb

@@ -10,25 +10,25 @@ describe RubyParser do
 
   context '.ruby' do
     it 'puts a bad syntax ruby file in the error files array' do
-      RubyParser.ruby([fixtures_dir + 'lib/syntax.rb'], false, [])
+      RubyParser.ruby(["#{fixtures_dir}lib/syntax.rb"], false, [])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}lib/syntax.rb:\n.*syntax error})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
-      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}lib/style.rb:\n.*Useless assignment.*\n.*Use the new.*\n.*Do not introduce.*\n.*Prefer single.*\n.*Source code comment is empty.*\n.*is a writable attribute.*\n.*Issue has no descriptive comment})
+      expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}lib/style.rb:\n.*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.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}lib/good.rb"])
@@ -37,25 +37,29 @@ describe RubyParser do
 
   context '.template' do
     it 'puts a bad syntax ruby template file in the error files array' do
-      RubyParser.template([fixtures_dir + 'templates/syntax.erb'])
-      expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.erb:\n.*syntax error, unexpected tIDENTIFIER})
+      RubyParser.template(["#{fixtures_dir}templates/syntax.erb"])
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
+        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.erb:\n.*1: syntax error, unexpected.*\n.*ruby})
+      else
+        expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}templates/syntax.erb:\n.*syntax error, unexpected tIDENTIFIER})
+      end
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}templates/style.erb:\n.*already initialized constant.*\n.*previous definition of})
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).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.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}templates/good.erb"])
@@ -64,25 +68,25 @@ describe RubyParser do
 
   context '.librarian' do
     it 'puts a bad syntax librarian Puppet file in the error files array' do
-      RubyParser.librarian([fixtures_dir + 'librarian_syntax/Puppetfile'], false, [])
+      RubyParser.librarian(["#{fixtures_dir}librarian_syntax/Puppetfile"], false, [])
       expect(PuppetCheck.settings[:error_files][0]).to match(%r{^#{fixtures_dir}librarian_syntax/Puppetfile:\n.*syntax error})
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql([])
     end
     it 'puts a bad style librarian Puppet file in the warning files array' do
-      RubyParser.librarian([fixtures_dir + 'librarian_style/Puppetfile'], true, [])
+      RubyParser.librarian(["#{fixtures_dir}librarian_style/Puppetfile"], true, [])
       expect(PuppetCheck.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files][0]).to match(%r{^#{fixtures_dir}librarian_style/Puppetfile:\n.*Align the arguments.*\n.*Use the new})
       expect(PuppetCheck.settings[:clean_files]).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_style/Puppetfile'], true, ['--except', 'Layout/AlignArguments,Style/HashSyntax'])
+      RubyParser.librarian(["#{fixtures_dir}librarian_style/Puppetfile"], true, ['--except', 'Layout/ArgumentAlignment,Style/HashSyntax'])
       expect(PuppetCheck.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}librarian_style/Puppetfile"])
     end
     it 'puts a good librarian Puppet file in the clean files array' do
-      RubyParser.librarian([fixtures_dir + 'librarian_good/Puppetfile'], true, [])
+      RubyParser.librarian(["#{fixtures_dir}librarian_good/Puppetfile"], true, [])
       expect(PuppetCheck.settings[:error_files]).to eql([])
       expect(PuppetCheck.settings[:warning_files]).to eql([])
       expect(PuppetCheck.settings[:clean_files]).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])

data/spec/puppet-check/tasks_spec.rb

@@ -1,12 +1,12 @@
 require 'rake/task'
-require_relative '../spec_helper.rb'
+require_relative '../spec_helper'
 require_relative '../../lib/puppet-check/tasks'
 
 describe PuppetCheck::Tasks do
   after(:all) do
     # cleanup rspec_puppet_setup
-    %w[spec/spec_helper.rb].each { |file| File.delete(file) }
-    %w[manifests modules].each { |dir| FileUtils.rm_r('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

data/spec/{puppet-check_spec.rb → puppet_check_spec.rb}

@@ -1,5 +1,5 @@
 require_relative 'spec_helper'
-require_relative '../lib/puppet-check'
+require_relative '../lib/puppet_check'
 
 describe PuppetCheck do
   context 'self' do

data/spec/spec_helper.rb

@@ -4,8 +4,13 @@ require 'rspec'
 module Variables
   extend RSpec::SharedContext
 
-  let(:fixtures_dir) { File.dirname(__FILE__) + '/fixtures/' }
-  let(:octocatalog_diff_dir) { File.dirname(__FILE__) + '/octocatalog-diff/' }
+  def fixtures_dir
+    @fixtures_dir = "#{File.dirname(__FILE__)}/fixtures/"
+  end
+
+  def octocatalog_diff_dir
+    @octocatalog_diff_dir = "#{File.dirname(__FILE__)}/octocatalog-diff/"
+  end
 end
 
 RSpec.configure do |config|

data/spec/system/system_spec.rb

@@ -1,15 +1,15 @@
 require 'rake/task'
-require_relative '../spec_helper.rb'
+require_relative '../spec_helper'
 require_relative '../../lib/puppet-check/cli'
 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 File.directory?('/home/travis')
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Metrics/LineLength,Style/Encoding .]) }
+    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 .]) }
     else
-      let(:cli) { PuppetCheck::CLI.run(%w[-s --puppet-lint no-hard_tabs-check,no-140chars-check --rubocop Metrics/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 --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,9 +17,9 @@ describe PuppetCheck do
 
       expect { cli }.not_to raise_exception
 
-      expect(PuppetCheck.settings[:error_files].length).to eql(9)
-      expect(PuppetCheck.settings[:warning_files].length).to eql(10)
-      expect(PuppetCheck.settings[:clean_files].length).to eql(12)
+      expect(PuppetCheck.settings[:error_files].length).to eql(10)
+      expect(PuppetCheck.settings[:warning_files].length).to eql(11)
+      expect(PuppetCheck.settings[:clean_files].length).to eql(13)
       expect(PuppetCheck.settings[:ignored_files].length).to eql(6)
 
       expect(cli).to eql(2)
@@ -40,18 +40,20 @@ describe PuppetCheck do
       PuppetCheck.settings[:ignored_files] = []
       PuppetCheck.settings[:style] = true
       # see regression_check_spec
-      unless File.directory?('/home/travis')
+      unless ENV['TRAVIS'] == 'true' || ENV['CIRCLECI'] == 'true' || ENV['GITHUB_ACTIONS'] == 'true'
         PuppetCheck.settings[:smoke] = true
         PuppetCheck.settings[:octonodes] = %w[good.example.com]
         PuppetCheck.settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'
       end
 
-      expect { tasks }.not_to raise_exception
+      # cannot re-use plan fixture between system tests
+      expect { tasks }.to raise_error(ArgumentError, /Attempt to redefine entity/)
 
-      expect(PuppetCheck.settings[:error_files].length).to eql(9)
-      expect(PuppetCheck.settings[:warning_files].length).to eql(10)
-      expect(PuppetCheck.settings[:clean_files].length).to eql(12)
-      expect(PuppetCheck.settings[:ignored_files].length).to eql(6)
+      # current puppet pops limitations no longer allow testing this
+      # expect(PuppetCheck.settings[:error_files].length).to eql(10)
+      # expect(PuppetCheck.settings[:warning_files].length).to eql(11)
+      # expect(PuppetCheck.settings[:clean_files].length).to eql(13)
+      # expect(PuppetCheck.settings[:ignored_files].length).to eql(6)
     end
   end
 end