puppetlabs-onceover 5.0.3 → 5.0.5

data/spec/puppetlabs-onceover/runner_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/controlrepo' # side effect: defines top-level #logger
+require 'puppetlabs-onceover/test'
+require 'puppetlabs-onceover/rspec/formatters'
+require 'puppetlabs-onceover/runner'
+
+describe PuppetlabsOnceover::Runner do
+  let(:repo) do
+    double(
+      'repo',
+      tempdir: '/tmp/onceover-runner-spec',
+      environmentpath: 'etc/puppetlabs/code/environments',
+      hiera_config: nil,
+      root: '/tmp/onceover-runner-spec-root'
+    )
+  end
+
+  def build_config(overrides = {})
+    double(
+      'config',
+      {
+        copy_spec_files: nil,
+        write_rakefile: nil,
+        write_spec_helper: nil,
+        write_spec_helper_acceptance: nil,
+        spec_tests: [],
+        verify_spec_test: nil,
+        run_filters: [],
+        write_spec_test: nil,
+        acceptance_tests: [],
+        verify_acceptance_test: nil,
+        write_acceptance_tests: nil,
+        create_fixtures_symlinks: nil,
+        filter_tags: nil,
+        fail_fast: false,
+        opts: {},
+        formatters: []
+      }.merge(overrides)
+    )
+  end
+
+  let(:config) { build_config }
+
+  before do
+    # Avoid any real filesystem churn from FileUtils calls in #prepare!
+    allow(FileUtils).to receive(:rm_rf)
+    allow(FileUtils).to receive(:rm_f)
+    allow(FileUtils).to receive(:mkdir_p)
+  end
+
+  describe '#initialize' do
+    it 'wraps a single symbol mode into an array' do
+      runner = described_class.new(repo, config, :spec)
+      expect(runner.instance_variable_get(:@mode)).to eq([:spec])
+    end
+
+    it 'accepts an array of modes as-is' do
+      runner = described_class.new(repo, config, [:spec, :acceptance])
+      expect(runner.instance_variable_get(:@mode)).to eq([:spec, :acceptance])
+    end
+
+    it 'defaults the mode to spec and acceptance' do
+      runner = described_class.new(repo, config)
+      expect(runner.instance_variable_get(:@mode)).to eq([:spec, :acceptance])
+    end
+
+    it 'sets an empty command prefix when BUNDLE_GEMFILE is not set' do
+      original = ENV.delete('BUNDLE_GEMFILE')
+      runner = described_class.new(repo, config)
+      expect(runner.instance_variable_get(:@command_prefix)).to eq('')
+      ENV['BUNDLE_GEMFILE'] = original if original
+    end
+
+    it 'sets a bundle exec command prefix when BUNDLE_GEMFILE is set' do
+      original = ENV.fetch('BUNDLE_GEMFILE', nil)
+      ENV['BUNDLE_GEMFILE'] = 'Gemfile'
+      runner = described_class.new(repo, config)
+      expect(runner.instance_variable_get(:@command_prefix)).to eq('bundle exec ')
+      if original
+        ENV['BUNDLE_GEMFILE'] = original
+      else
+        ENV.delete('BUNDLE_GEMFILE')
+      end
+    end
+  end
+
+  describe '#prepare!' do
+    it 'runs the spec test path when mode includes :spec' do
+      runner = described_class.new(repo, config, :spec)
+
+      expect(config).to receive(:spec_tests).at_least(:once).and_return(['sometest'])
+      expect(config).to receive(:verify_spec_test).with(repo, 'sometest')
+      expect(PuppetlabsOnceover::Test).to receive(:deduplicate).with(['sometest']).and_return(['sometest'])
+      expect(config).to receive(:run_filters).with(['sometest']).and_return(['sometest'])
+      expect(config).to receive(:write_spec_test).with("#{repo.tempdir}/spec/classes", 'sometest')
+      expect(config).not_to receive(:acceptance_tests)
+
+      runner.prepare!
+    end
+
+    it 'runs the acceptance test path when mode includes :acceptance' do
+      runner = described_class.new(repo, config, :acceptance)
+
+      expect(config).to receive(:acceptance_tests).at_least(:once).and_return(['sometest'])
+      expect(config).to receive(:verify_acceptance_test).with(repo, 'sometest')
+      expect(PuppetlabsOnceover::Test).to receive(:deduplicate).with(['sometest']).and_return(['sometest'])
+      expect(config).to receive(:run_filters).with(['sometest']).and_return(['sometest'])
+      expect(config).to receive(:write_acceptance_tests).with("#{repo.tempdir}/spec/acceptance", ['sometest'])
+      expect(config).not_to receive(:spec_tests)
+
+      runner.prepare!
+    end
+
+    it 'runs neither test path when mode is empty' do
+      runner = described_class.new(repo, config, [])
+
+      expect(config).not_to receive(:spec_tests)
+      expect(config).not_to receive(:acceptance_tests)
+
+      runner.prepare!
+    end
+
+    it 'skips the hiera rewrite when hiera_config is nil' do
+      runner = described_class.new(repo, config, [])
+      expect(File).not_to receive(:write)
+      runner.prepare!
+    end
+
+    it 'rewrites a plain (non-hash) hiera_config setting untouched and writes hiera.yaml' do
+      hiera_repo = double(
+        'repo',
+        tempdir: '/tmp/onceover-runner-spec',
+        environmentpath: 'etc/puppetlabs/code/environments',
+        hiera_config: { 'version' => 5 },
+        root: '/tmp/onceover-runner-spec-root'
+      )
+      runner = described_class.new(hiera_repo, config, [])
+
+      expect(File).to receive(:write).with(
+        "#{hiera_repo.tempdir}/#{hiera_repo.environmentpath}/production/hiera.yaml",
+        { 'version' => 5 }.to_yaml
+      )
+
+      runner.prepare!
+    end
+
+    it 'rewrites the datadir of a hierarchy hash entry to point at the tempdir' do
+      hiera_config = {
+        'hierarchy' => { datadir: 'hieradata' }
+      }
+      hiera_repo = double(
+        'repo',
+        tempdir: '/tmp/onceover-runner-spec',
+        environmentpath: 'etc/puppetlabs/code/environments',
+        hiera_config: hiera_config,
+        root: '/tmp/onceover-runner-spec-root'
+      )
+      runner = described_class.new(hiera_repo, config, [])
+
+      expected_datadir = "#{hiera_repo.tempdir}/#{hiera_repo.environmentpath}/production/hieradata"
+
+      expect(File).to receive(:write) do |path, contents|
+        expect(path).to eq("#{hiera_repo.tempdir}/#{hiera_repo.environmentpath}/production/hiera.yaml")
+        expect(contents).to include(expected_datadir)
+      end
+
+      runner.prepare!
+    end
+
+    it 'leaves a hash entry without a :datadir key untouched' do
+      hiera_config = {
+        'hierarchy' => { other_key: 'value' }
+      }
+      hiera_repo = double(
+        'repo',
+        tempdir: '/tmp/onceover-runner-spec',
+        environmentpath: 'etc/puppetlabs/code/environments',
+        hiera_config: hiera_config,
+        root: '/tmp/onceover-runner-spec-root'
+      )
+      runner = described_class.new(hiera_repo, config, [])
+
+      expect(File).to receive(:write) do |_path, contents|
+        expect(contents).not_to include('/tmp/onceover-runner-spec/etc')
+      end
+
+      runner.prepare!
+    end
+  end
+
+  describe '#run_spec!' do
+    let(:backticks_double) do
+      double('backticks_runner', run: double('process', join: double('joined', status: double('status', exitstatus: 0))))
+    end
+
+    before do
+      allow(Backticks::Runner).to receive(:new).and_return(backticks_double)
+      allow(Dir).to receive(:chdir).and_yield
+      allow($stderr).to receive(:isatty).and_return(false)
+    end
+
+    it 'runs rake spec:standalone in standalone mode and exits with the status code' do
+      runner = described_class.new(repo, config, :spec)
+      logger.level = :info
+
+      expect(runner).to receive(:exit).with(0)
+      runner.run_spec!
+    end
+
+    it 'runs rake parallel_spec when opts[:parallel] is set' do
+      parallel_config = build_config(opts: { parallel: true })
+      runner = described_class.new(repo, parallel_config, :spec)
+      logger.level = :info
+
+      expect(runner).to receive(:run_command).with(anything, 'rake', 'parallel_spec').and_call_original
+      allow(runner).to receive(:exit)
+      runner.run_spec!
+    end
+
+    it 'skips the RUBYOPT warning-suppression dance when logger level is debug (zero)' do
+      runner = described_class.new(repo, config, :spec)
+      logger.level = :debug
+
+      previous = ENV.fetch('RUBYOPT', nil)
+      expect(runner).to receive(:exit).with(0)
+      runner.run_spec!
+      expect(ENV.fetch('RUBYOPT', nil)).to eq(previous)
+      logger.level = :info
+    end
+
+    it 'appends filter tags and fail-fast to CI_SPEC_OPTIONS when configured' do
+      tagged_config = build_config(filter_tags: ['sometag'], fail_fast: true)
+      runner = described_class.new(repo, tagged_config, :spec)
+      logger.level = :info
+
+      allow(runner).to receive(:exit)
+      runner.run_spec!
+      expect(ENV.fetch('CI_SPEC_OPTIONS', nil)).to include('--tag sometag')
+      expect(ENV.fetch('CI_SPEC_OPTIONS', nil)).to include('--fail-fast')
+      ENV.delete('CI_SPEC_OPTIONS')
+    end
+
+    it 'prints a parallel summary when the parallel formatter is configured' do
+      formatter_config = build_config(formatters: ['PuppetlabsOnceoverFormatterParallel'])
+      runner = described_class.new(repo, formatter_config, :spec)
+      logger.level = :info
+
+      formatter_double = double('formatter', output_results: nil)
+      expect(PuppetlabsOnceoverFormatterParallel).to receive(:new).with($stdout).and_return(formatter_double)
+      expect(formatter_double).to receive(:output_results).with("#{repo.tempdir}/parallel")
+
+      allow(runner).to receive(:exit)
+      runner.run_spec!
+    end
+  end
+
+  describe '#run_acceptance!' do
+    let(:backticks_double) do
+      double('backticks_runner', run: double('process', join: double('joined', status: double('status', exitstatus: 1))))
+    end
+
+    before do
+      allow(Backticks::Runner).to receive(:new).and_return(backticks_double)
+      allow(Dir).to receive(:chdir).and_yield
+      allow($stderr).to receive(:isatty).and_return(false)
+    end
+
+    it 'warns about deprecation and runs rake acceptance' do
+      # NOTE: `result` in the source is assigned only inside the Dir.chdir
+      # block and then read again after the block returns -- that's normal
+      # Ruby block-local scoping, so `result` is actually undefined at the
+      # `exit result.status.exitstatus` line and this method always raises
+      # NameError there in real usage. That's a pre-existing bug in
+      # lib/puppetlabs-onceover/runner.rb, not something we can cover
+      # without changing production behavior, so we assert the crash
+      # instead of the (unreachable) exit call.
+      runner = described_class.new(repo, config, :acceptance)
+
+      expect(runner).to receive(:warn).with(/DEPRECATION/)
+      expect { runner.run_acceptance! }.to raise_error(NameError, /result/)
+    end
+  end
+
+  describe '#run_command' do
+    it 'sets STDERR raw when a tty and cooked afterwards' do
+      runner = described_class.new(repo, config, :spec)
+      backticks_double = double('backticks_runner', run: double('process', join: double('joined')))
+      allow(Backticks::Runner).to receive(:new).and_return(backticks_double)
+      allow($stderr).to receive(:isatty).and_return(true)
+      expect($stderr).to receive(:raw!)
+      expect($stderr).to receive(:cooked!)
+
+      runner.run_command('rake', 'spec:standalone')
+    end
+
+    it 'does not touch STDERR raw/cooked state when not a tty' do
+      runner = described_class.new(repo, config, :spec)
+      backticks_double = double('backticks_runner', run: double('process', join: double('joined')))
+      allow(Backticks::Runner).to receive(:new).and_return(backticks_double)
+      allow($stderr).to receive(:isatty).and_return(false)
+      expect($stderr).not_to receive(:raw!)
+      expect($stderr).not_to receive(:cooked!)
+
+      runner.run_command('rake', 'spec:standalone')
+    end
+  end
+end

data/spec/puppetlabs-onceover/test_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+require 'puppetlabs-onceover/test'
+require 'puppetlabs-onceover/class'
+require 'puppetlabs-onceover/node'
+require 'puppetlabs-onceover/group'
+require 'puppetlabs-onceover/testconfig'
+require 'puppetlabs-onceover/controlrepo'
+
+describe "PuppetlabsOnceover::Test" do
+  before(:each) do
+    PuppetlabsOnceover::Class.class_variable_set(:@@all, [])
+    PuppetlabsOnceover::Node.class_variable_set(:@@all, [])
+    PuppetlabsOnceover::Group.class_variable_set(:@@all, [])
+    PuppetlabsOnceover::Test.class_variable_set(:@@all, [])
+    logger.level = :fatal
+    PuppetlabsOnceover::Controlrepo.new(path: 'spec/fixtures/controlrepos/factsets')
+  end
+
+  let(:node_a) { PuppetlabsOnceover::Node.new('node_a') }
+  let(:node_b) { PuppetlabsOnceover::Node.new('node_b') }
+  let(:class_a) { PuppetlabsOnceover::Class.new('role::a') }
+  let(:class_b) { PuppetlabsOnceover::Class.new('role::b') }
+
+  describe "#initialize" do
+    it "merges in the default test_config (check_idempotency/runs_before_idempotency)" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      expect(test.test_config['check_idempotency']).to eq(true)
+      expect(test.test_config['runs_before_idempotency']).to eq(1)
+    end
+
+    it "lets explicit test_config values override the defaults" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, { 'check_idempotency' => false })
+      expect(test.test_config['check_idempotency']).to eq(false)
+    end
+
+    it "removes 'classes' from the stored test_config" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, { 'classes' => 'whatever' })
+      expect(test.test_config).not_to have_key('classes')
+    end
+
+    it "normalizes a single tag string into an array" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, { 'tags' => 'sometag' })
+      expect(test.tags).to eq(['sometag'])
+    end
+
+    it "leaves an array of tags as-is" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, { 'tags' => %w[a b] })
+      expect(test.tags).to eq(%w[a b])
+    end
+
+    it "defaults tags to an empty array when absent" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      expect(test.tags).to eq([])
+    end
+
+    context "resolving the 'on_this' (node) argument" do
+      it "accepts a group name and expands it to its member nodes" do
+        PuppetlabsOnceover::Group.new('nodegroup', [node_a, node_b])
+        test = PuppetlabsOnceover::Test.new('nodegroup', class_a, {})
+        expect(test.nodes).to eq([node_a, node_b])
+      end
+
+      it "accepts a plain node name" do
+        test = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+        expect(test.nodes).to eq([node_a])
+      end
+
+      it "raises when the node/group cannot be found" do
+        expect do
+          PuppetlabsOnceover::Test.new('no_such_node_or_group', class_a, {})
+        end.to raise_error(RuntimeError, /was not found in the list of nodes or groups/)
+      end
+    end
+
+    context "resolving the 'test_this' (classes) argument" do
+      it "accepts a group name and expands it to its member classes" do
+        PuppetlabsOnceover::Group.new('classgroup', [class_a, class_b])
+        test = PuppetlabsOnceover::Test.new(node_a.name, 'classgroup', {})
+        expect(test.classes).to eq([class_a, class_b])
+      end
+
+      it "accepts a plain class name" do
+        test = PuppetlabsOnceover::Test.new(node_a.name, class_a.name, {})
+        expect(test.classes).to eq([class_a])
+      end
+
+      it "raises when given a string that matches neither a class nor a group" do
+        expect do
+          PuppetlabsOnceover::Test.new(node_a.name, 'no_such_class_or_group', {})
+        end.to raise_error(RuntimeError, /was not found in the list of classes or groups/)
+      end
+
+      it "accepts a subtractive include/exclude hash" do
+        PuppetlabsOnceover::Group.new('all_classes', [class_a, class_b])
+        PuppetlabsOnceover::Group.new('excluded', [class_b])
+        test = PuppetlabsOnceover::Test.new(node_a.name, { 'include' => 'all_classes', 'exclude' => 'excluded' }, {})
+        expect(test.classes).to eq([class_a])
+      end
+
+      it "accepts a Class object directly" do
+        test = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+        expect(test.classes).to eq([class_a])
+      end
+    end
+  end
+
+  describe "#eql?" do
+    it "is true when both nodes and classes match once sorted" do
+      t1 = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      t2 = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      expect(t1.eql?(t2)).to eq(true)
+    end
+
+    it "is false when the classes differ" do
+      t1 = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      t2 = PuppetlabsOnceover::Test.new(node_a.name, class_b, {})
+      expect(t1.eql?(t2)).to eq(false)
+    end
+  end
+
+  describe "#to_s" do
+    it "uses the singular class and node name when there is only one of each" do
+      test = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      expect(test.to_s).to eq("role__a_on_node_a")
+    end
+
+    it "summarizes as N_classes when there are multiple classes" do
+      PuppetlabsOnceover::Group.new('classgroup', [class_a, class_b])
+      test = PuppetlabsOnceover::Test.new(node_a.name, 'classgroup', {})
+      expect(test.to_s).to eq("2_classes_on_node_a")
+    end
+
+    it "summarizes as N_nodes when there are multiple nodes" do
+      PuppetlabsOnceover::Group.new('nodegroup', [node_a, node_b])
+      test = PuppetlabsOnceover::Test.new('nodegroup', class_a, {})
+      expect(test.to_s).to eq("role__a_on_2_nodes")
+    end
+  end
+
+  describe ".deduplicate" do
+    it "merges duplicate node/class combinations into a single test, keeping non-default config" do
+      t1 = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      t2 = PuppetlabsOnceover::Test.new(node_a.name, class_a, { 'check_idempotency' => false })
+
+      deduped = PuppetlabsOnceover::Test.deduplicate([t1, t2])
+      expect(deduped.length).to eq(1)
+      expect(deduped.first.test_config['check_idempotency']).to eq(false)
+    end
+
+    it "leaves distinct node/class combinations as separate tests" do
+      t1 = PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      t2 = PuppetlabsOnceover::Test.new(node_b.name, class_b, {})
+
+      deduped = PuppetlabsOnceover::Test.deduplicate([t1, t2])
+      expect(deduped.length).to eq(2)
+    end
+
+    it "handles tests with multiple nodes/classes by expanding every combination" do
+      PuppetlabsOnceover::Group.new('nodegroup', [node_a, node_b])
+      PuppetlabsOnceover::Group.new('classgroup', [class_a, class_b])
+      t1 = PuppetlabsOnceover::Test.new('nodegroup', 'classgroup', {})
+
+      deduped = PuppetlabsOnceover::Test.deduplicate([t1])
+      # 2 nodes x 2 classes = 4 distinct combinations
+      expect(deduped.length).to eq(4)
+    end
+  end
+
+  describe ".all" do
+    # Unlike Class/Node/Group, Test#initialize never appends `self` to @@all,
+    # so .all is always empty in practice -- documenting actual behavior here.
+    it "returns the (always empty) @@all class variable, since #initialize never appends to it" do
+      PuppetlabsOnceover::Test.new(node_a.name, class_a, {})
+      expect(PuppetlabsOnceover::Test.all).to eq([])
+    end
+  end
+end