puppetlabs-onceover 5.0.3 → 5.0.5

data/spec/puppetlabs-onceover/rake_tasks_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'rake'
+require 'ostruct'
+
+describe 'rake_tasks.rb' do
+  # SimpleCov/Coverage tracks a given file path's hit-lines against the ISeq
+  # produced by the FIRST time it's compiled in this process. Re-`load`ing
+  # the file fresh in a before(:each) (once per example) makes every example
+  # after the first exercise a *new*, uninstrumented compilation, so real
+  # task-body coverage silently reads back as 0. Instead we `load` the file
+  # exactly once for the whole group, and use `Rake::Task#reenable` before
+  # each invoke so a task can be invoked again in a later example.
+  rake_tasks_path = File.expand_path('../../lib/puppetlabs-onceover/rake_tasks.rb', __dir__)
+  Rake.application = Rake::Application.new
+  load rake_tasks_path
+
+  before(:each) do
+    Rake::Task.tasks.each(&:reenable)
+  end
+
+  describe 'generate_fixtures' do
+    it 'writes fixtures.yml when it does not already exist' do
+      repo = double('repo', root: '/tmp/nonexistent_root_for_test', fixtures: "fixture_content")
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(File.expand_path('./.fixtures.yml', repo.root)).and_return(false)
+      allow(File).to receive(:write)
+
+      Rake::Task['generate_fixtures'].invoke
+
+      expect(File).to have_received(:write).with(File.expand_path('./.fixtures.yml', repo.root), 'fixture_content')
+    end
+
+    it 'raises when fixtures.yml already exists' do
+      repo = double('repo', root: '/tmp/nonexistent_root_for_test')
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(File.expand_path('./.fixtures.yml', repo.root)).and_return(true)
+
+      expect { Rake::Task['generate_fixtures'].invoke }.to raise_error(/already exits/)
+    end
+  end
+
+  describe 'hiera_setup' do
+    it 'updates the datadir for hash values containing datadir and writes the new config' do
+      hiera_config = { defaults: { datadir: 'orig/data' } }
+      repo = double('repo')
+      allow(repo).to receive(:hiera_config).and_return(hiera_config)
+      # Use File.expand_path so these are real OS-native absolute paths on any
+      # platform (Windows Pathname#relative_path_from raises "different prefix"
+      # when comparing a bare '/some/repo'-style path against one that's been
+      # expanded to a drive-letter path).
+      allow(repo).to receive(:hiera_config_file).and_return(File.expand_path('/some/repo/hiera.yaml'))
+      allow(repo).to receive(:hiera_data).and_return(File.expand_path('/some/repo/data'))
+      allow(repo).to receive(:hiera_config=)
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      Rake::Task['hiera_setup'].invoke
+
+      expect(repo).to have_received(:hiera_config=) do |new_config|
+        expect(new_config[:defaults][:datadir]).to eq('data')
+      end
+    end
+
+    it 'leaves non-hash values alone' do
+      hiera_config = { version: 5 }
+      repo = double('repo')
+      allow(repo).to receive(:hiera_config).and_return(hiera_config)
+      allow(repo).to receive(:hiera_config_file).and_return('/some/repo/hiera.yaml')
+      allow(repo).to receive(:hiera_data).and_return('/some/repo/data')
+      allow(repo).to receive(:hiera_config=)
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      Rake::Task['hiera_setup'].invoke
+
+      expect(repo).to have_received(:hiera_config=).with(hiera_config)
+    end
+  end
+
+  describe 'controlrepo_details' do
+    it 'prints the controlrepo to_s' do
+      repo = double('repo', to_s: 'REPO DETAILS')
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      expect { Rake::Task['controlrepo_details'].invoke }.to output(/REPO DETAILS/).to_stdout
+    end
+  end
+
+  describe 'generate_onceover_yaml' do
+    it 'reads the controlrepo and renders the controlrepo.yaml.erb template' do
+      repo = double('repo', roles: %w[role::web role::db], facts_files: ['/some/repo/facts/centos7.json', '/some/repo/facts/Windows_Server-2019.json'])
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      # ERB.new's legacy positional (safe_level, trim_mode) arguments were
+      # removed in the bundled erb gem (6.0.7+, Ruby 4.0) -- rake_tasks.rb
+      # used to pass them positionally, which raised ArgumentError on that
+      # Ruby before this fix. Now that it's fixed (keyword trim_mode:), this
+      # asserts the template actually renders real content from the repo
+      # double, not just that it "reaches" the call.
+      expect { Rake::Task['generate_onceover_yaml'].invoke }.to output(
+        a_string_including('role::web', 'role::db', 'centos7', 'Windows_Server-2019', 'Windows_Server-2019')
+      ).to_stdout
+    end
+  end
+
+  describe 'generate_nodesets' do
+    it 'writes a nodeset entry for each factset, handling a 404 box lookup' do
+      repo = double('repo')
+      allow(repo).to receive(:facts).and_return([{ 'os' => { 'family' => 'RedHat' } }])
+      allow(repo).to receive(:facts_files).and_return(['/some/repo/facts/centos7.json'])
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      require 'puppetlabs-onceover/beaker'
+      allow(PuppetlabsOnceover::Beaker).to receive(:facts_to_vagrant_box).and_return('centos/7')
+      allow(PuppetlabsOnceover::Beaker).to receive(:facts_to_platform).and_return('el-7-x86_64')
+
+      http_double = double('http', use_ssl: true, 'use_ssl=': true)
+      response = double('response', code: '404', body: '{}')
+      allow(Net::HTTP).to receive(:new).and_return(http_double)
+      allow(http_double).to receive(:get).and_return(response)
+
+      # This deprecated task (Beaker removed) has a second, deeper,
+      # pre-existing bug beyond the ERB.new Ruby-4.0 incompatibility fixed
+      # elsewhere: nodeset.yaml.erb expects a `hosts_hash` local (and a
+      # `prefix` local) that the task body never actually defines -- it
+      # builds flat locals (node_name/boxname/platform/url/comment_out)
+      # instead. Out of scope to redesign a deprecated task here; asserting
+      # the real resulting error (and that execution reaches it, covering
+      # the "HOSTS:" header and 404 branch first) rather than the old,
+      # now-fixed ArgumentError.
+      expect { Rake::Task['generate_nodesets'].invoke }.to raise_error(NameError, /hosts_hash/).and output(/HOSTS:/).to_stdout
+    end
+
+    it 'writes a nodeset entry using the virtualbox provider url when the box lookup succeeds' do
+      repo = double('repo')
+      allow(repo).to receive(:facts).and_return([{ 'os' => { 'family' => 'RedHat' } }])
+      allow(repo).to receive(:facts_files).and_return(['/some/repo/facts/centos7.json'])
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).and_return(repo)
+
+      require 'puppetlabs-onceover/beaker'
+      allow(PuppetlabsOnceover::Beaker).to receive(:facts_to_vagrant_box).and_return('centos/7')
+      allow(PuppetlabsOnceover::Beaker).to receive(:facts_to_platform).and_return('el-7-x86_64')
+
+      box_body = {
+        'current_version' => {
+          'providers' => [
+            { 'name' => 'virtualbox', 'original_url' => 'https://example.com/box.box' }
+          ]
+        }
+      }.to_json
+
+      http_double = double('http', use_ssl: true, 'use_ssl=': true)
+      response = double('response', code: '200', body: box_body)
+      allow(Net::HTTP).to receive(:new).and_return(http_double)
+      allow(http_double).to receive(:get).and_return(response)
+
+      # As above: covers the successful (non-404) lookup branch, including
+      # the virtualbox provider url extraction, before hitting the same
+      # pre-existing hosts_hash/prefix bug described above.
+      expect { Rake::Task['generate_nodesets'].invoke }.to raise_error(NameError, /hosts_hash/).and output(/HOSTS:/).to_stdout
+    end
+  end
+
+  describe 'generate_vendor_cache' do
+    it 'creates a VendoredModules cache for the controlrepo' do
+      repo = double('repo', spec_dir: '/some/repo/spec')
+      allow(PuppetlabsOnceover::Controlrepo).to receive(:new).with(debug: true).and_return(repo)
+
+      require 'puppetlabs-onceover/vendored_modules'
+      allow(PuppetlabsOnceover::VendoredModules).to receive(:new)
+
+      Rake::Task['generate_vendor_cache'].invoke
+
+      expect(PuppetlabsOnceover::VendoredModules).to have_received(:new).with(
+        hash_including(repo: repo, force_update: true)
+      )
+    end
+  end
+end

data/spec/puppetlabs-onceover/rspec/formatters_spec.rb

@@ -0,0 +1,361 @@
+require 'spec_helper'
+require 'stringio'
+require 'tmpdir'
+require 'fileutils'
+require 'yaml'
+require 'puppetlabs-onceover/controlrepo'
+require 'puppetlabs-onceover/rspec/formatters'
+
+describe PuppetlabsOnceoverFormatter do
+  let(:output) { StringIO.new }
+  subject(:formatter) { described_class.new(output) }
+
+  def group_double(description)
+    group = double('group', description: description)
+    allow(group).to receive(:parent_groups).and_return([group])
+    group
+  end
+
+  def stub_world_groups(descriptions)
+    groups = descriptions.map { |d| double('group', description: d) }
+    allow(RSpec.configuration.world).to receive(:example_groups).and_return(groups)
+  end
+
+  def failure_double(role:, factset:, raw_error:, description: 'a test', file_path: '/spec/foo_spec.rb', line_number: 5)
+    metadata = {
+      example_group: {
+        description: factset,
+        parent_example_group: { description: role }
+      },
+      execution_result: double('execution_result', exception: RuntimeError.new(raw_error)),
+      description: description,
+      file_path: file_path,
+      line_number: line_number
+    }
+    double('example', metadata: metadata)
+  end
+
+  describe '#example_group_started' do
+    context 'when the group is a top-level role' do
+      it 'prints the role name and sets previous_role' do
+        stub_world_groups(['role::foo', 'role::barbaz'])
+        group = group_double('role::foo')
+        notification = double('notification', group: group)
+
+        formatter.example_group_started(notification)
+
+        expect(output.string).to include('role::foo:')
+      end
+
+      it 'does not reprint the same role twice in a row' do
+        stub_world_groups(['role::foo'])
+        group = group_double('role::foo')
+        notification = double('notification', group: group)
+
+        formatter.example_group_started(notification)
+        first_output = output.string
+        formatter.example_group_started(notification)
+
+        expect(output.string).to eq(first_output)
+      end
+    end
+
+    context 'when the group is nested (not the top-level role)' do
+      it "prints '? ' as a placeholder" do
+        top = double('top_group')
+        group = double('group', description: 'nested context')
+        allow(group).to receive(:parent_groups).and_return([top, group])
+        notification = double('notification', group: group)
+
+        formatter.example_group_started(notification)
+
+        expect(output.string).to eq('? ')
+      end
+    end
+  end
+
+  describe '#example_passed' do
+    it 'writes a green P' do
+      formatter.example_passed(double('notification'))
+      expect(output.string).to include('P')
+    end
+  end
+
+  describe '#example_failed' do
+    it 'writes a red F' do
+      formatter.example_failed(double('notification'))
+      expect(output.string).to include('F')
+    end
+  end
+
+  describe '#example_pending' do
+    it 'writes a yellow ?' do
+      formatter.example_pending(double('notification'))
+      expect(output.string).to include('?')
+    end
+  end
+
+  describe '#parse_errors' do
+    it 'parses a compilation error with a file/line/column location' do
+      allow(RSpec.configuration).to receive(:onceover_tempdir).and_return('/tmp/xyz/.onceover')
+      allow(RSpec.configuration).to receive(:onceover_root).and_return('/tmp/xyz')
+      allow(RSpec.configuration).to receive(:onceover_environmentpath).and_return('etc/puppetlabs/code/environments')
+
+      raw = 'Some function failed error during compilation: bad value at (file: /tmp/xyz/.onceover/etc/puppetlabs/code/environments/production/site/role/manifests/foo.pp, line: 4, column: 2); more'
+      results = formatter.parse_errors(raw)
+      expect(results.first[:line]).to eq('4')
+      expect(results.first[:column]).to eq('2')
+      expect(results.first[:file]).to eq('site/role/manifests/foo.pp')
+    end
+
+    it 'parses a compilation error whose location omits the file' do
+      raw = 'error during compilation: bad value at (line: 9, column: 1); trailer'
+      results = formatter.parse_errors(raw)
+      expect(results.first[:file]).to be_nil
+      expect(results.first[:line]).to eq('9')
+    end
+
+    it 'parses a compilation error with no location at all, matching "on node"' do
+      raw = 'error during compilation: something bad happened on node foo.example.com'
+      results = formatter.parse_errors(raw)
+      expect(results.first[:text]).to eq('something bad happened')
+      expect(results.first[:file]).to be_nil
+    end
+
+    it 'falls back to the raw string when a compilation error matches neither location pattern' do
+      raw = 'error during compilation: nothing structured here whatsoever'
+      results = formatter.parse_errors(raw)
+      expect(results).to eq([{ text: raw }])
+    end
+
+    it 'falls back to the raw string for a non-compilation error' do
+      raw = "NoMethodError: undefined method 'foo' for nil"
+      results = formatter.parse_errors(raw)
+      expect(results).to eq([{ text: raw }])
+    end
+  end
+
+  describe '#calculate_relative_source' do
+    before do
+      allow(RSpec.configuration).to receive(:onceover_tempdir).and_return('/tmp/xyz/.onceover')
+      allow(RSpec.configuration).to receive(:onceover_root).and_return('/tmp/xyz')
+      allow(RSpec.configuration).to receive(:onceover_environmentpath).and_return('etc/puppetlabs/code/environments')
+    end
+
+    it 'returns nil when given a nil file' do
+      expect(formatter.calculate_relative_source(nil)).to be_nil
+    end
+
+    it 'calculates the path relative to the production environment root' do
+      file = '/tmp/xyz/.onceover/etc/puppetlabs/code/environments/production/site/role/manifests/foo.pp'
+      expect(formatter.calculate_relative_source(file)).to eq('site/role/manifests/foo.pp')
+    end
+  end
+
+  describe '#extract_failure_data' do
+    it 'attaches the list of failing factsets to each parsed error' do
+      fails = [
+        failure_double(role: 'role::foo', factset: 'using fact set centos-7-x86_64', raw_error: 'boom'),
+        failure_double(role: 'role::foo', factset: 'using fact set windows-2019-x64', raw_error: 'boom')
+      ]
+      results = formatter.extract_failure_data(fails)
+      expect(results.first[:factsets]).to eq(['centos-7-x86_64', 'windows-2019-x64'])
+    end
+  end
+
+  describe '#extract_failures' do
+    it 'groups failures by role and then by distinct error message' do
+      notification = double(
+        'notification',
+        failed_examples: [
+          failure_double(role: 'role::foo', factset: 'using fact set centos-7-x86_64', raw_error: 'boom one'),
+          failure_double(role: 'role::foo', factset: 'using fact set windows-2019-x64', raw_error: 'boom two'),
+          failure_double(role: 'role::bar', factset: 'using fact set centos-7-x86_64', raw_error: 'boom three')
+        ]
+      )
+
+      grouped = formatter.extract_failures(notification)
+
+      expect(grouped.keys).to contain_exactly('role::foo', 'role::bar')
+      expect(grouped['role::foo'].size).to eq(2)
+      expect(grouped['role::bar'].size).to eq(1)
+    end
+  end
+
+  describe '#dump_failures' do
+    before do
+      allow(RSpec.configuration).to receive(:onceover_tempdir).and_return('/tmp/xyz/.onceover')
+      allow(RSpec.configuration).to receive(:onceover_root).and_return('/tmp/xyz')
+      allow(RSpec.configuration).to receive(:onceover_environmentpath).and_return('etc/puppetlabs/code/environments')
+    end
+
+    it 'renders the error summary template for each failing role' do
+      notification = double(
+        'notification',
+        failed_examples: [
+          failure_double(role: 'role::foo', factset: 'using fact set centos-7-x86_64', raw_error: 'boom')
+        ]
+      )
+
+      formatter.dump_failures(notification)
+
+      expect(output.string).to include('role::foo')
+      expect(output.string).to include('failed')
+    end
+  end
+
+  describe '#longest_group' do
+    it 'returns the length of the longest example group description' do
+      stub_world_groups(['role::a', 'role::much_longer_name'])
+      expect(formatter.longest_group).to eq('role::much_longer_name'.length)
+    end
+  end
+
+  describe 'color helper methods' do
+    [:class_name, :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, :bold].each do |method|
+      it "##{method} wraps the given text" do
+        expect(formatter.public_send(method, 'hello')).to be_a(String)
+        expect(formatter.public_send(method, 'hello')).to include('hello')
+      end
+    end
+  end
+end
+
+describe PuppetlabsOnceoverFormatterParallel do
+  let(:output) { StringIO.new }
+  subject(:formatter) { described_class.new(output) }
+
+  def failure_double(role:, factset:, raw_error:)
+    metadata = {
+      example_group: {
+        description: factset,
+        parent_example_group: { description: role }
+      },
+      execution_result: double('execution_result', exception: RuntimeError.new(raw_error))
+    }
+    double('example', metadata: metadata)
+  end
+
+  describe '#example_group_started' do
+    it 'does nothing' do
+      expect { formatter.example_group_started(double('notification')) }.not_to raise_error
+      expect(output.string).to eq('')
+    end
+  end
+
+  describe '#example_passed' do
+    it 'writes and flushes a green P' do
+      formatter.example_passed(double('notification'))
+      expect(output.string).to include('P')
+    end
+  end
+
+  describe '#example_failed' do
+    it 'writes and flushes a red F' do
+      formatter.example_failed(double('notification'))
+      expect(output.string).to include('F')
+    end
+  end
+
+  describe '#example_pending' do
+    it 'writes and flushes a yellow ?' do
+      formatter.example_pending(double('notification'))
+      expect(output.string).to include('?')
+    end
+  end
+
+  describe '#dump_failures' do
+    it 'dumps a yaml file of the failures into the parallel results dir' do
+      tempdir = Dir.mktmpdir
+      allow(RSpec.configuration).to receive(:onceover_tempdir).and_return(tempdir)
+
+      notification = double(
+        'notification',
+        failed_examples: [failure_double(role: 'role::foo', factset: 'using fact set centos-7-x86_64', raw_error: 'boom')]
+      )
+
+      formatter.dump_failures(notification)
+
+      files = Dir["#{tempdir}/parallel/*.yaml"]
+      expect(files.size).to eq(1)
+      expect(YAML.load_file(files.first)).to have_key('role::foo')
+
+      FileUtils.remove_entry(tempdir)
+    end
+  end
+
+  describe '#output_results' do
+    before do
+      allow(RSpec.configuration).to receive(:onceover_tempdir).and_return('/tmp/xyz/.onceover')
+      allow(RSpec.configuration).to receive(:onceover_root).and_return('/tmp/xyz')
+      allow(RSpec.configuration).to receive(:onceover_environmentpath).and_return('etc/puppetlabs/code/environments')
+    end
+
+    it 'merges all yaml result files, renders them, and deletes the source files' do
+      directory = Dir.mktmpdir
+      File.write(File.join(directory, 'results-1.yaml'), { 'role::foo' => [{ text: 'boom one' }] }.to_yaml)
+      File.write(File.join(directory, 'results-2.yaml'), { 'role::bar' => [{ text: 'boom two' }] }.to_yaml)
+
+      formatter.output_results(directory)
+
+      expect(output.string).to include('role::foo')
+      expect(output.string).to include('role::bar')
+      expect(Dir["#{directory}/*.yaml"]).to be_empty
+
+      FileUtils.remove_entry(directory)
+    end
+
+    it 'merges values when the same role appears in multiple files' do
+      directory = Dir.mktmpdir
+      File.write(File.join(directory, 'results-1.yaml'), { 'role::foo' => [{ text: 'boom one' }] }.to_yaml)
+      File.write(File.join(directory, 'results-2.yaml'), { 'role::foo' => [{ text: 'boom two' }] }.to_yaml)
+
+      formatter.output_results(directory)
+
+      expect(output.string).to include('role::foo')
+
+      FileUtils.remove_entry(directory)
+    end
+  end
+end
+
+describe FailureCollector do
+  let(:tempdir) { Dir.mktmpdir }
+
+  before do
+    allow(RSpec.configuration).to receive(:onceover_tempdir).and_return(tempdir)
+  end
+
+  after { FileUtils.rm_rf(tempdir) }
+
+  describe '#initialize' do
+    it 'touches a failures.out file in the onceover tempdir' do
+      described_class.new(StringIO.new)
+      expect(File.exist?(File.join(tempdir, 'failures.out'))).to be true
+    end
+  end
+
+  describe '#dump_failures' do
+    it 'appends details of each failed example to failures.out' do
+      collector = described_class.new(StringIO.new)
+
+      fe = double(
+        'failed_example',
+        metadata: {
+          description: 'does a thing',
+          execution_result: double('execution_result', exception: RuntimeError.new('kaboom')),
+          file_path: '/spec/foo_spec.rb',
+          line_number: 12
+        }
+      )
+      failures = double('failures', failed_examples: [fe])
+
+      collector.dump_failures(failures)
+
+      contents = File.read(File.join(tempdir, 'failures.out'))
+      expect(contents).to include('does a thing')
+      expect(contents).to include('kaboom')
+      expect(contents).to include('/spec/foo_spec.rb:12')
+    end
+  end
+end