puppet-check 2.2.0 → 2.2.1

data/spec/puppet-check/ruby_parser_spec.rb

@@ -3,93 +3,102 @@ require_relative '../../lib/puppet-check/ruby_parser'
 
 describe RubyParser do
   before(:each) do
-    PuppetCheck.settings[:error_files] = []
-    PuppetCheck.settings[:warning_files] = []
-    PuppetCheck.settings[:clean_files] = []
+    PuppetCheck.files = {
+      errors: {},
+      warnings: {},
+      clean: [],
+      ignored: []
+    }
   end
 
   context '.ruby' do
-    it 'puts a bad syntax ruby file in the error files array' do
+    it 'puts a bad syntax ruby file in the error files hash' do
       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([])
+      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[: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, [])
-      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.*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([])
+      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[: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'])
-      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"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      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, [])
-      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"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      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 array' 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"])
       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})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(%r{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})
+        expect(PuppetCheck.files[:errors]["#{fixtures_dir}templates/syntax.erb"].join("\n")).to match(%r{syntax error, unexpected tIDENTIFIER})
       end
-      expect(PuppetCheck.settings[:warning_files]).to eql([])
-      expect(PuppetCheck.settings[:clean_files]).to eql([])
+      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"])
-      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([])
+      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[: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"])
-      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"])
+      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"])
     end
     it 'puts a good ruby template file in the clean files array' do
       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"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      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 array' 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.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([])
+      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[: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_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([])
+      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[: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_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"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).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, [])
-      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"])
+      expect(PuppetCheck.files[:errors]).to eql({})
+      expect(PuppetCheck.files[:warnings]).to eql({})
+      expect(PuppetCheck.files[:clean]).to eql(["#{fixtures_dir}librarian_good/Puppetfile"])
     end
   end
 end

data/spec/puppet-check/tasks_spec.rb

@@ -10,7 +10,7 @@ describe PuppetCheck::Tasks do
   end
 
   context 'puppetcheck:spec' do
-    let(:spec_tasks) { Rake::Task['puppetcheck:spec'.to_sym].invoke }
+    let(:spec_tasks) { Rake::Task[:'puppetcheck:spec'].invoke }
 
     it 'executes RSpec and RSpec-Puppet checks in the expected manner' do
       Dir.chdir(fixtures_dir)
@@ -23,23 +23,19 @@ describe PuppetCheck::Tasks do
   end
 
   context 'puppetcheck:beaker' do
-    let(:beaker_task) { Rake::Task['puppetcheck:beaker'.to_sym].invoke }
+    let(:beaker_task) { Rake::Task[:'puppetcheck:beaker'].invoke }
 
     it 'verifies the Beaker task exists' do
-      Dir.chdir(fixtures_dir)
-
       # beaker task executed
       expect { beaker_task }.to output("Beaker is not installed. The Beaker tasks will not be available.\n").to_stdout
     end
   end
 
   context 'puppetcheck:kitchen' do
-    let(:kitchen_task) { Rake::Task['puppetcheck:kitchen'.to_sym].invoke }
+    let(:kitchen_task) { Rake::Task[:'puppetcheck:kitchen'].invoke }
 
     it 'verifies the Kitchen task exists' do
-      Dir.chdir(fixtures_dir)
-
-      # beaker task executed
+      # kitchen task executed
       expect { kitchen_task }.to output("Test Kitchen is not installed. The Kitchen tasks will not be available.\n").to_stdout
     end
   end

data/spec/puppet_check_spec.rb

@@ -3,30 +3,68 @@ require_relative '../lib/puppet_check'
 
 describe PuppetCheck do
   context 'self' do
-    it 'settings can be altered' do
-      expect(PuppetCheck.settings[:future_parser]).to eql(nil)
-      PuppetCheck.settings[:fail_on_warnings] = true
-      expect(PuppetCheck.settings[:fail_on_warnings]).to eql(true)
-      PuppetCheck.settings[:style] = true
-      expect(PuppetCheck.settings[:style]).to eql(true)
-      PuppetCheck.settings[:smoke] = true
-      expect(PuppetCheck.settings[:smoke]).to eql(true)
-      PuppetCheck.settings[:regression] = true
-      expect(PuppetCheck.settings[:regression]).to eql(true)
-      PuppetCheck.settings[:public] = 'public.pem'
-      expect(PuppetCheck.settings[:public]).to eql('public.pem')
-      PuppetCheck.settings[:private] = 'private.pem'
-      expect(PuppetCheck.settings[:private]).to eql('private.pem')
-      PuppetCheck.settings[:output_format] = 'text'
-      expect(PuppetCheck.settings[:output_format]).to eql('text')
-      PuppetCheck.settings[:octoconfig] = '.octocatalog-diff.cfg.rb'
-      expect(PuppetCheck.settings[:octoconfig]).to eql('.octocatalog-diff.cfg.rb')
-      PuppetCheck.settings[:octonodes] = %w[localhost.localdomain]
-      expect(PuppetCheck.settings[:octonodes]).to eql(%w[localhost.localdomain])
-      PuppetCheck.settings[:puppetlint_args] = ['--puppetlint-arg-one', '--puppetlint-arg-two']
-      expect(PuppetCheck.settings[:puppetlint_args]).to eql(['--puppetlint-arg-one', '--puppetlint-arg-two'])
-      PuppetCheck.settings[:rubocop_args] = ['--rubocop-arg-one', '--rubocop-arg-two']
-      expect(PuppetCheck.settings[:rubocop_args]).to eql(['--rubocop-arg-one', '--rubocop-arg-two'])
+    it 'files are initialized correctly' do
+      expect(PuppetCheck.files).to eql(
+        {
+          errors: {},
+          warnings: {},
+          clean: [],
+          ignored: []
+        }
+      )
+    end
+    it 'files can be altered' do
+      PuppetCheck.files = {
+        errors: { 'foo' => ['i had an error'] },
+        warnings: { 'foo' => ['i had a warning'] },
+        clean: ['foo'],
+        ignored: ['foo']
+      }
+      expect(PuppetCheck.files).to eql(
+        {
+          errors: { 'foo' => ['i had an error'] },
+          warnings: { 'foo' => ['i had a warning'] },
+          clean: ['foo'],
+          ignored: ['foo']
+        }
+      )
+    end
+  end
+
+  context 'defaults' do
+    it 'returns defaults correctly' do
+      expect(PuppetCheck.defaults).to eql(
+        {
+          fail_on_warning: false,
+          style: false,
+          smoke: false,
+          regression: false,
+          public: nil,
+          private: nil,
+          output_format: 'text',
+          octoconfig: '.octocatalog-diff.cfg.rb',
+          octonodes: %w[localhost.localdomain],
+          puppetlint_args: [],
+          rubocop_args: []
+        }
+      )
+    end
+
+    it 'modifies settings correctly' do
+      settings = {
+        fail_on_warning: true,
+        style: true,
+        smoke: true,
+        regression: true,
+        public: 'public.pem',
+        private: 'private.pem',
+        output_format: 'yaml',
+        octoconfig: '.octocatalog-diff.cfg.erb',
+        octonodes: %w[host.domain],
+        puppetlint_args: %w[--puppetlint-arg-one --puppetlint-arg-two],
+        rubocop_args: %w[--rubocop-arg-one --rubocop-arg-two]
+      }
+      expect(PuppetCheck.defaults(settings)).to eql(settings)
     end
   end
 
@@ -73,7 +111,7 @@ describe PuppetCheck do
       # expect(parser_output).to receive(:yaml).with(%w[yaml.yaml yaml.yml])
       # expect(parser_output).to receive(:json).with(%w[json.json])
       # expect(parser_output).to receive(:librarian).with(%w[Puppetfile Modulefile])
-      # expect(PuppetCheck.settings[:ignored_files]).to eql(%w[foobarbaz])
+      # expect(PuppetCheck.files[:ignored]).to eql(%w[foobarbaz])
     end
   end
 end

data/spec/system/system_spec.rb

@@ -17,43 +17,43 @@ describe PuppetCheck do
 
       expect { cli }.not_to raise_exception
 
-      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(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(cli).to eql(2)
     end
   end
 
   context 'executed as a system from the Rakefile with arguments and various files to be processed' do
-    let(:tasks) { Rake::Task['puppetcheck:file'.to_sym].invoke }
-
     it 'outputs diagnostic results correctly after processing all of the files' do
       # ensure rake only checks the files inside fixtures
       Dir.chdir(fixtures_dir)
 
-      # clear out arrays from previous system test
-      PuppetCheck.settings[:error_files] = []
-      PuppetCheck.settings[:warning_files] = []
-      PuppetCheck.settings[:clean_files] = []
-      PuppetCheck.settings[:ignored_files] = []
-      PuppetCheck.settings[:style] = true
+      # clear out files member from previous system test
+      PuppetCheck.files = {
+        errors: {},
+        warnings: {},
+        clean: [],
+        ignored: []
+      }
+      settings = { style: true }
       # see regression_check_spec
       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'
+        settings[:smoke] = true
+        settings[:octonodes] = %w[good.example.com]
+        settings[:octoconfig] = 'spec/octocatalog-diff/octocatalog-diff.cfg.rb'
       end
 
       # cannot re-use plan fixture between system tests
-      expect { tasks }.to raise_error(ArgumentError, /Attempt to redefine entity/)
+      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.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(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)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-check
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Matt Schuchard
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-10 00:00:00.000000000 Z
+date: 2023-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: puppet
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5.5'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5.5'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -34,16 +34,22 @@ dependencies:
   name: puppet-lint
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: reek
   requirement: !ruby/object:Gem::Requirement
@@ -232,61 +238,4 @@ signing_key:
 specification_version: 4
 summary: A streamlined comprehensive set of checks for your entire Puppet code and
   data
-test_files:
-- spec/fixtures/foobarbaz
-- spec/fixtures/hieradata/good.eyaml
-- spec/fixtures/hieradata/good.json
-- spec/fixtures/hieradata/good.yaml
-- spec/fixtures/hieradata/style.eyaml
-- spec/fixtures/hieradata/style.yaml
-- spec/fixtures/hieradata/syntax.eyaml
-- spec/fixtures/hieradata/syntax.json
-- spec/fixtures/hieradata/syntax.yaml
-- spec/fixtures/keys/private_key.pkcs7.pem
-- spec/fixtures/keys/public_key.pkcs7.pem
-- spec/fixtures/lib/good.rb
-- spec/fixtures/lib/rubocop_style.rb
-- spec/fixtures/lib/style.rb
-- spec/fixtures/lib/syntax.rb
-- spec/fixtures/librarian_good/Puppetfile
-- spec/fixtures/librarian_style/Puppetfile
-- spec/fixtures/librarian_syntax/Puppetfile
-- spec/fixtures/manifests/eof_syntax.pp
-- spec/fixtures/manifests/good.pp
-- spec/fixtures/manifests/style_lint.pp
-- spec/fixtures/manifests/style_parser.pp
-- spec/fixtures/manifests/syntax.pp
-- spec/fixtures/metadata.json
-- spec/fixtures/metadata_good/metadata.json
-- spec/fixtures/metadata_style/metadata.json
-- spec/fixtures/metadata_style_two/metadata.json
-- spec/fixtures/metadata_syntax/metadata.json
-- spec/fixtures/plans/good.pp
-- spec/fixtures/plans/style.pp
-- spec/fixtures/plans/syntax.pp
-- spec/fixtures/spec/facter/facter_spec.rb
-- spec/fixtures/spec/fixtures/do_not_parse_me
-- spec/fixtures/task_metadata/task_bad.json
-- spec/fixtures/task_metadata/task_good.json
-- spec/fixtures/templates/good.epp
-- spec/fixtures/templates/good.erb
-- spec/fixtures/templates/no_method_error.erb
-- spec/fixtures/templates/style.erb
-- spec/fixtures/templates/syntax.epp
-- spec/fixtures/templates/syntax.erb
-- spec/octocatalog-diff/facts.yaml
-- spec/octocatalog-diff/hiera.yaml
-- spec/octocatalog-diff/manifests/site.pp
-- spec/octocatalog-diff/octocatalog_diff.cfg.rb
-- spec/puppet-check/cli_spec.rb
-- spec/puppet-check/data_parser_spec.rb
-- spec/puppet-check/output_results_spec.rb
-- spec/puppet-check/puppet_parser_spec.rb
-- spec/puppet-check/regression_check_spec.rb
-- spec/puppet-check/rspec_puppet_support_spec.rb
-- spec/puppet-check/ruby_parser_spec.rb
-- spec/puppet-check/tasks_spec.rb
-- spec/puppet-check/utils_spec.rb
-- spec/puppet_check_spec.rb
-- spec/spec_helper.rb
-- spec/system/system_spec.rb
+test_files: []