puppetlabs_spec_helper 4.0.1 → 5.0.1

data/spec/unit/puppetlabs_spec_helper/puppetlabs_spec/puppet_internals_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rspec-puppet'
+
+describe PuppetlabsSpec::PuppetInternals do
+  before(:all) do # this is only needed once # rubocop:disable RSpec/BeforeAfterAll
+    Puppet.initialize_settings
+  end
+
+  describe '.resource' do
+    subject(:resource) { described_class.resource }
+
+    it 'can have a defined type' do
+      expect(described_class.resource(type: :node).type).to eq(:node)
+    end
+
+    it 'defaults to a type of hostclass' do
+      expect(resource.type).to eq(:hostclass)
+    end
+
+    it 'can have a defined name' do
+      expect(described_class.resource(name: 'testingrsrc').name).to eq('testingrsrc')
+    end
+
+    it 'defaults to a name of testing' do
+      expect(resource.name).to eq('testing')
+    end
+  end
+
+  describe '.compiler' do
+    let(:node) { described_class.node }
+
+    it 'can have a defined node' do
+      expect(described_class.compiler(node: node).node).to be node
+    end
+  end
+
+  describe '.node' do
+    it 'can have a defined name' do
+      expect(described_class.node(name: 'mine').name).to eq('mine')
+    end
+
+    it 'can have a defined environment' do
+      expect(described_class.node(environment: 'mine').environment.name).to eq(:mine)
+    end
+
+    it 'defaults to a name of testinghost' do
+      expect(described_class.node.name).to eq('testinghost')
+    end
+
+    it 'accepts facts via options for rspec-puppet' do
+      fact_values = { 'fqdn' => 'jeff.puppetlabs.com' }
+      node = described_class.node(options: { parameters: fact_values })
+      expect(node.parameters).to eq(fact_values)
+    end
+  end
+
+  describe '.function_method', type: :puppet_function do
+    it 'accepts an injected scope' do
+      expect(Puppet::Parser::Functions).to receive(:function).with('my_func').and_return(true)
+      expect(scope).to receive(:method).with(:function_my_func).and_return(:fake_method)
+      expect(described_class.function_method('my_func', scope: scope)).to eq(:fake_method)
+    end
+
+    it "returns nil if the function doesn't exist" do
+      expect(Puppet::Parser::Functions).to receive(:function).with('my_func').and_return(false)
+      expect(described_class.function_method('my_func', scope: scope)).to be_nil
+    end
+  end
+end

data/spec/unit/puppetlabs_spec_helper/tasks/check_symlinks_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'rake check:symlinks', type: :task do
+  before(:each) do
+    test_files.each do |f|
+      FileUtils.mkdir_p(File.dirname(f))
+      FileUtils.touch(f)
+    end
+
+    symlinks.each do |link, target|
+      FileUtils.mkdir_p(File.dirname(link))
+      FileUtils.ln_s(target, link)
+    end
+  end
+
+  let(:test_files) { [] }
+  let(:symlinks) { {} }
+  let(:expected_output) do
+    symlinks.map { |link, target| "Symlink found: #{link} => #{target}" }.join("\n")
+  end
+
+  context 'when there are no files' do
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there are regular files' do
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+        File.join(Dir.pwd, 'files', 'another_file.pp'),
+      ]
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there is a symlink present' do
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, 'files', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'raises an error' do
+      expect { task.execute }
+        .to raise_error(%r{symlink\(s\) exist}i)
+        .and output(a_string_including(expected_output)).to_stdout
+    end
+  end
+
+  context 'when there are symlinks under .git/' do
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, '.git', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there are symlinks under .bundle/' do
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, '.bundle', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there are symlinks under vendor/' do
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, 'vendor', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there are symlinks under a directory listed in .gitignore' do
+    before(:each) do
+      File.write(File.join(Dir.pwd, '.gitignore'), "a_directory/\n")
+    end
+
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, 'a_directory', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there are symlinks under a directory listed in .pdkignore' do
+    before(:each) do
+      File.open(File.join(Dir.pwd, '.pdkignore'), 'w') do |f|
+        f.puts '/another_directory/'
+      end
+    end
+
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'files', 'a_file.pp'),
+      ]
+    end
+
+    let(:symlinks) do
+      {
+        File.join(Dir.pwd, 'another_directory', 'a_symlink.pp') => File.join(Dir.pwd, 'files', 'a_file.pp'),
+      }
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+end

data/spec/unit/puppetlabs_spec_helper/tasks/check_test_file_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'rake check:test_file', type: :task do
+  context 'when there are .pp files under tests/' do
+    before(:each) do
+      test_files.each do |f|
+        FileUtils.mkdir_p(File.dirname(f))
+        FileUtils.touch(f)
+      end
+    end
+
+    let(:test_files) do
+      [
+        File.join(Dir.pwd, 'tests', 'an_example.pp'),
+        File.join(Dir.pwd, 'tests', 'deep', 'directory', 'structure', 'another_example.pp'),
+      ]
+    end
+
+    it 'raises an error' do
+      expected_output = test_files.join("\n")
+
+      expect { task.execute }
+        .to raise_error(%r{pp files present in tests folder})
+        .and output(a_string_including(expected_output)).to_stdout
+    end
+  end
+
+  context 'when there are no .pp files under tests/' do
+    before(:each) do
+      FileUtils.mkdir('tests')
+    end
+
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+
+  context 'when there is no tests/ directory' do
+    it 'runs without raising an error' do
+      expect { task.execute }.not_to raise_error
+    end
+  end
+end

data/spec/unit/puppetlabs_spec_helper/tasks/fixtures_spec.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'puppetlabs_spec_helper/tasks/fixtures'
+
+describe PuppetlabsSpecHelper::Tasks::FixtureHelpers do
+  describe '.module_name' do
+    subject(:module_name) { described_class.module_name }
+
+    before(:each) do
+      allow(Dir).to receive(:pwd).and_return(File.join('path', 'to', 'my-awsome-module_from_pwd'))
+    end
+
+    shared_examples 'module name from working directory' do
+      it 'determines the module name from the working directory name' do
+        expect(module_name).to eq('module_from_pwd')
+      end
+    end
+
+    shared_examples 'module name from metadata' do
+      it 'determines the module name from the module metadata' do
+        expect(module_name).to eq('module_from_metadata')
+      end
+    end
+
+    context 'when metadata.json does not exist' do
+      before(:each) do
+        allow(File).to receive(:file?).with('metadata.json').and_return(false)
+      end
+
+      it_behaves_like 'module name from working directory'
+    end
+
+    context 'when metadata.json does exist' do
+      before(:each) do
+        allow(File).to receive(:file?).with('metadata.json').and_return(true)
+      end
+
+      context 'but it is not readable' do
+        before(:each) do
+          allow(File).to receive(:readable?).with('metadata.json').and_return(false)
+        end
+
+        it_behaves_like 'module name from working directory'
+      end
+
+      context 'and it is readable' do
+        before(:each) do
+          allow(File).to receive(:readable?).with('metadata.json').and_return(true)
+          allow(File).to receive(:read).with('metadata.json').and_return(metadata_content)
+        end
+
+        context 'but it contains invalid JSON' do
+          let(:metadata_content) { '{ "name": "my-awesome-module_from_metadata", }' }
+
+          it_behaves_like 'module name from working directory'
+        end
+
+        context 'and it contains a name value' do
+          let(:metadata_content) { '{ "name": "my-awesome-module_from_metadata" }' }
+
+          it_behaves_like 'module name from metadata'
+        end
+
+        context 'but it does not contain a name value' do
+          let(:metadata_content) { '{}' }
+
+          it_behaves_like 'module name from working directory'
+        end
+
+        context 'but the name has a null value' do
+          let(:metadata_content) { '{ "name": null }' }
+
+          it_behaves_like 'module name from working directory'
+        end
+
+        context 'but the name is blank' do
+          let(:metadata_content) { '{ "name": "" }' }
+
+          it_behaves_like 'module name from working directory'
+        end
+      end
+    end
+  end
+
+  describe '.fixtures' do
+    subject(:helper) { described_class }
+
+    before :each do
+      # Unstub the fixtures "helpers"
+      PuppetlabsSpec::Fixtures.instance_methods.each do |m|
+        PuppetlabsSpec::Fixtures.send(:undef_method, m)
+      end
+      allow(File).to receive(:exist?).with('.fixtures.yml').and_return false
+      allow(File).to receive(:exist?).with('.fixtures.yaml').and_return false
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('FIXTURES_YML').and_return(nil)
+      allow(described_class).to receive(:auto_symlink).and_return('project' => source_dir.to_s)
+    end
+
+    context 'when file is missing' do
+      it 'returns basic directories per category' do
+        expect(helper.fixtures('forge_modules')).to eq({})
+        expect(helper.fixtures('repositories')).to eq({})
+      end
+    end
+
+    context 'when file is empty' do
+      it 'returns basic directories per category' do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return false
+        expect(helper.fixtures('forge_modules')).to eq({})
+        expect(helper.fixtures('repositories')).to eq({})
+      end
+    end
+
+    context 'when file is malformed' do
+      it 'raises an error' do
+        expect(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        expect(YAML).to receive(:load_file).with('.fixtures.yml').and_raise(Psych::SyntaxError.new('/file', '123', '0', '0', 'spec message', 'spec context'))
+        expect { helper.fixtures('forge_modules') }.to raise_error(RuntimeError, %r{malformed YAML})
+      end
+    end
+
+    context 'when file contains no fixtures' do
+      it 'raises an error' do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return('some' => 'key')
+        expect { helper.fixtures('forge_modules') }.to raise_error(RuntimeError, %r{No 'fixtures'})
+      end
+    end
+
+    context 'when file specifies fixtures' do
+      it 'returns the hash' do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return('fixtures' => { 'forge_modules' => { 'stdlib' => 'puppetlabs-stdlib' } })
+        expect(helper.fixtures('forge_modules')).to eq(
+          'puppetlabs-stdlib' => {
+            'target' => 'spec/fixtures/modules/stdlib',
+            'ref' => nil,
+            'branch' => nil,
+            'scm' => nil,
+            'flags' => nil,
+            'subdir' => nil,
+          },
+        )
+      end
+    end
+
+    context 'when file specifies defaults' do
+      it 'returns the hash' do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return('defaults' => { 'forge_modules' => { 'flags' => '--module_repository=https://myforge.example.com/' } },
+                                                                            'fixtures' => { 'forge_modules' => { 'stdlib' => 'puppetlabs-stdlib' } })
+        expect(helper.fixtures('forge_modules')).to eq(
+          'puppetlabs-stdlib' => {
+            'target' => 'spec/fixtures/modules/stdlib',
+            'ref' => nil,
+            'branch' => nil,
+            'scm' => nil,
+            'flags' => '--module_repository=https://myforge.example.com/',
+            'subdir' => nil,
+          },
+        )
+      end
+    end
+
+    context 'when file specifies repository fixtures' do
+      before(:each) do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return(
+          'fixtures' => {
+            'repositories' => { 'stdlib' => 'https://github.com/puppetlabs/puppetlabs-stdlib.git' },
+          },
+        )
+      end
+
+      it 'returns the hash' do
+        expect(helper.repositories).to eq(
+          'https://github.com/puppetlabs/puppetlabs-stdlib.git' => {
+            'target' => 'spec/fixtures/modules/stdlib',
+            'ref' => nil,
+            'branch' => nil,
+            'scm' => nil,
+            'flags' => nil,
+            'subdir' => nil,
+          },
+        )
+      end
+    end
+
+    context 'when file specifies repository fixtures with an invalid git ref' do
+      before(:each) do
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return(
+          'fixtures' => {
+            'repositories' => {
+              'stdlib' => {
+                'scm' => 'git',
+                'repo' => 'https://github.com/puppetlabs/puppetlabs-stdlib.git',
+                'ref' => 'this/is/a/branch',
+              },
+            },
+          },
+        )
+      end
+
+      it 'raises an ArgumentError' do
+        expect { helper.fixtures('repositories') }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when file specifies puppet version' do
+      def stub_fixtures(data)
+        allow(File).to receive(:exist?).with('.fixtures.yml').and_return true
+        allow(YAML).to receive(:load_file).with('.fixtures.yml').and_return(data)
+      end
+
+      it 'includes the fixture if the puppet version matches', if: Gem::Version.new(Puppet::PUPPETVERSION) > Gem::Version.new('4') do
+        stub_fixtures(
+          'fixtures' => {
+            'forge_modules' => {
+              'stdlib' => {
+                'repo' => 'puppetlabs-stdlib',
+                'puppet_version' => Puppet::PUPPETVERSION,
+              },
+            },
+          },
+        )
+        expect(helper.fixtures('forge_modules')).to include('puppetlabs-stdlib')
+      end
+
+      it 'excludes the fixture if the puppet version does not match', if: Gem::Version.new(Puppet::PUPPETVERSION) > Gem::Version.new('4') do
+        stub_fixtures(
+          'fixtures' => {
+            'forge_modules' => {
+              'stdlib' => {
+                'repo' => 'puppetlabs-stdlib',
+                'puppet_version' => '>= 999.9.9',
+              },
+            },
+          },
+        )
+        expect(helper.fixtures('forge_modules')).to eq({})
+      end
+
+      it 'includes the fixture on obsolete puppet versions', if: Gem::Version.new(Puppet::PUPPETVERSION) <= Gem::Version.new('4') do
+        stub_fixtures(
+          'fixtures' => {
+            'forge_modules' => {
+              'stdlib' => {
+                'repo' => 'puppetlabs-stdlib',
+                'puppet_version' => Puppet::PUPPETVERSION,
+              },
+            },
+          },
+        )
+        expect(helper.fixtures('forge_modules')).to include('puppetlabs-stdlib')
+      end
+    end
+  end
+end

data/spec/watchr.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+ENV['FOG_MOCK'] ||= 'true'
+ENV['AUTOTEST'] = 'true'
+ENV['WATCHR']   = '1'
+
+system 'clear'
+
+def growl(message)
+  growlnotify = `which growlnotify`.chomp
+  title = 'Watchr Test Results'
+  image = case message
+          when %r{(\d+)\s+?(failure|error)}i
+            (Regexp.last_match(1).to_i == 0) ? '~/.watchr_images/passed.png' : '~/.watchr_images/failed.png'
+          else
+            '~/.watchr_images/unknown.png'
+          end
+  options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
+  system %(#{growlnotify} #{options} &)
+end
+
+def run(cmd)
+  puts(cmd)
+  `#{cmd}`
+end
+
+def run_spec_test(file)
+  if File.exist? file
+    result = run "rspec --format p #{file}"
+    growl result.split("\n").last
+    puts result
+  else
+    puts "FIXME: No test #{file} [#{Time.now}]"
+  end
+end
+
+def filter_rspec(data)
+  data.split("\n").select { |l|
+    l =~ %r{^(\d+)\s+exampl\w+.*?(\d+).*?failur\w+.*?(\d+).*?pending}
+  }.join("\n")
+end
+
+def run_all_tests
+  system('clear')
+  files = Dir.glob('spec/**/*_spec.rb').join(' ')
+  result = run "rspec #{files}"
+  growl_results = filter_rspec result
+  growl growl_results
+  puts result
+  puts "GROWL: #{growl_results}"
+end
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts 'Interrupt a second time to quit'
+    @interrupted = true
+    Kernel.sleep 1.5
+    # raise Interrupt, nil # let the run loop catch it
+    run_suite
+  end
+end
+
+watch('spec/.*_spec\.rb') do |_md|
+  run_all_tests
+end
+
+watch('lib/.*\.rb') do |_md|
+  run_all_tests
+end