akerl-r10k 3.14.2.1

data/spec/unit/util/attempt_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'r10k/util/attempt'
+
+describe R10K::Util::Attempt do
+
+  describe "with a single truthy value" do
+    subject(:attempt) { described_class.new("hello") }
+
+    it "invokes the next action with the value" do
+      value = nil
+      attempt.try { |inner| value = inner }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(value).to eq "hello"
+    end
+
+    it "returns the resulting value from the block" do
+      attempt.try { |inner| inner + " world" }
+      result = attempt.run
+      expect(attempt).to be_ok
+      expect(result).to eq "hello world"
+    end
+  end
+
+  describe "with a false value" do
+    subject(:attempt) { described_class.new(nil) }
+
+    it "does not evaluate the block" do
+      value = "outside of block"
+      attempt.try { |inner| value = "ran block" }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(value).to eq "outside of block"
+    end
+
+    it "does not continue execution" do
+      attempt.try { |_| "something" }.try { raise }
+      expect(attempt.run).to be_nil
+    end
+  end
+
+  describe "with an array" do
+    subject(:attempt) { described_class.new([1, 2, 3, 4, 5]) }
+
+    it "runs the block for each element in the array" do
+      sum = 0
+      attempt.try { |inner| sum += inner }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(sum).to eq 15
+    end
+
+    it "returns the result of the operation on each array member" do
+      sum = 0
+      attempt.try { |inner| sum += inner }
+      result = attempt.run
+      expect(result).to eq([1, 3, 6, 10, 15])
+    end
+  end
+
+  describe "when an exception is raised" do
+    subject(:attempt) { described_class.new("initial") }
+
+    it "returns the exception" do
+      attempt.try { |_| raise RuntimeError }
+      result = attempt.run
+      expect(attempt).to_not be_ok
+      expect(result).to be_a_kind_of RuntimeError
+    end
+
+    it "does not continue execution" do
+      attempt.try { |_| raise RuntimeError }.try { |_| "This should not be run" }
+      result = attempt.run
+      expect(result).to be_a_kind_of RuntimeError
+    end
+
+    it "only rescues descendants of StandardError" do
+      attempt.try { |_| raise Exception }
+      expect { attempt.run }.to raise_error(Exception)
+    end
+  end
+end

data/spec/unit/util/cacheable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'r10k/util/cacheable'
+
+RSpec.describe R10K::Util::Cacheable do
+
+  subject { Object.new.extend(R10K::Util::Cacheable) }
+
+  describe "dirname sanitization" do
+    let(:input) { 'https://some/git/remote' }
+
+    it 'sanitizes URL to directory name' do
+      expect(subject.sanitized_dirname(input)).to eq('https---some-git-remote')
+    end
+
+    context 'with username and password' do
+      let(:input) { 'https://"user:pa$$w0rd:@authenticated/git/remote' }
+
+      it 'sanitizes authenticated URL to directory name' do
+        expect(subject.sanitized_dirname(input)).to eq('https---authenticated-git-remote')
+      end
+    end
+  end
+end

data/spec/unit/util/commands_spec.rb

@@ -0,0 +1,61 @@
+require 'r10k/util/commands'
+require 'r10k/util/exec_env'
+
+require 'tmpdir'
+
+describe R10K::Util::Commands do
+  describe "#which" do
+
+    before do
+      allow(File).to receive(:executable?).and_return false
+      allow(File).to receive(:file?).and_return false
+    end
+
+    def stub_executable(exe)
+      allow(File).to receive(:executable?).with(exe).and_return true
+      allow(File).to receive(:file?).with(exe).and_return true
+    end
+
+    describe "when ENV['PATHEXT'] is unset" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => nil, 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+
+    describe "when ENV['PATHEXT'] is set" do
+      let(:path) { Dir.mktmpdir }
+
+      around(:each) do |example|
+        R10K::Util::ExecEnv.withenv('PATHEXT' => '.bat;.exe;.cmd', 'PATH' => path) do
+          example.run
+        end
+      end
+
+      it "returns the first matching command in PATH" do
+        exe = File.join(path, 'git.exe')
+        stub_executable(exe)
+        expect(described_class.which("git")).to eq exe
+      end
+
+      it "returns nil if the command could not be found" do
+        exe = File.join(path, 'git.exe')
+        expect(described_class.which("git")).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/util/downloader_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'r10k/util/downloader'
+
+describe R10K::Util::Downloader do
+
+  subject(:downloader) do
+    subj = Object.new
+    subj.extend(R10K::Util::Downloader)
+    subj.singleton_class.class_eval { public :download }
+    subj.singleton_class.class_eval { public :http_get }
+    subj.singleton_class.class_eval { public :file_digest }
+    subj
+  end
+
+  let(:tmpdir) { Dir.mktmpdir }
+  after(:each) { FileUtils.remove_entry_secure(tmpdir) }
+
+  describe 'http_get' do
+    let(:src_url) { 'https://example.com' }
+    let(:dst_file) { File.join(tmpdir, 'test.out') }
+    let(:tarball_uri) { URI('http://tarball.example.com/tarball.tar.gz') }
+    let(:redirect_uri) { URI('http://redirect.example.com/redirect') }
+    let(:proxy_uri) { URI('http://user:password@proxy.example.com') }
+
+    it 'downloads a simple file' do
+      mock_session = instance_double('Net::HTTP', active?: true)
+      tarball_response = instance_double('Net::HTTPSuccess')
+
+      expect(Net::HTTP).to receive(:new).with(tarball_uri.host, any_args).and_return(mock_session)
+      expect(Net::HTTPSuccess).to receive(:===).with(tarball_response).and_return(true)
+
+      expect(mock_session).to receive(:request_get).and_yield(tarball_response)
+      expect(mock_session).to receive(:start).once
+      expect(mock_session).to receive(:finish).once
+
+      expect { |b| downloader.http_get(tarball_uri, &b) }.to yield_with_args(tarball_response)
+    end
+
+    it 'follows redirects' do
+      mock_session_1 = instance_double('Net::HTTP', active?: false)
+      mock_session_2 = instance_double('Net::HTTP', active?: true)
+      redirect_response = instance_double('Net::HTTPRedirection')
+      tarball_response = instance_double('Net::HTTPSuccess')
+
+      expect(Net::HTTP).to receive(:new).with(redirect_uri.host, any_args).and_return(mock_session_1).once
+      expect(Net::HTTP).to receive(:new).with(tarball_uri.host, any_args).and_return(mock_session_2).once
+      expect(Net::HTTPRedirection).to receive(:===).with(redirect_response).and_return(true)
+      expect(Net::HTTPSuccess).to receive(:===).with(tarball_response).and_return(true)
+      allow(Net::HTTPRedirection).to receive(:===).and_call_original
+
+      expect(mock_session_1).to receive(:request_get).and_yield(redirect_response)
+      expect(mock_session_2).to receive(:request_get).and_yield(tarball_response)
+
+      # The redirect response should be queried for the redirect location
+      expect(redirect_response).to receive(:[]).with('location').and_return(tarball_uri.to_s)
+
+      # Both sessions should start and finish cleanly
+      expect(mock_session_1).to receive(:start).once
+      expect(mock_session_1).to receive(:finish).once
+      expect(mock_session_2).to receive(:start).once
+      expect(mock_session_2).to receive(:finish).once
+
+      expect { |b| downloader.http_get(redirect_uri, &b) }.to yield_with_args(tarball_response)
+    end
+
+    it 'can use a proxy' do
+      mock_session = instance_double('Net::HTTP', active?: true)
+
+      expect(Net::HTTP).to receive(:new)
+                       .with(tarball_uri.host,
+                             tarball_uri.port,
+                             proxy_uri.host,
+                             proxy_uri.port,
+                             proxy_uri.user,
+                             proxy_uri.password,
+                             any_args)
+                       .and_return(mock_session)
+
+      expect(mock_session).to receive(:request_get).and_return(:not_yielded)
+      expect(mock_session).to receive(:start).once
+      expect(mock_session).to receive(:finish).once
+
+      downloader.http_get(tarball_uri, proxy: proxy_uri)
+    end
+  end
+
+  describe 'checksums' do
+    let(:fixture_checksum) { '0bcea17aa0c5e868c18f0fa042feda770e47c1a4223229f82116ccb3ca33c6e3' }
+    let(:fixture_tarball) do
+      File.expand_path('spec/fixtures/integration/git/puppet-boolean-bare.tar', PROJECT_ROOT)
+    end
+
+    it 'checksums files' do
+      expect(downloader.file_digest(fixture_tarball)).to eql(fixture_checksum)
+    end
+  end
+end
+

data/spec/unit/util/exec_env_spec.rb

@@ -0,0 +1,56 @@
+require 'r10k/util/exec_env'
+
+describe R10K::Util::ExecEnv do
+  describe "withenv" do
+    it "adds the keys to the environment during the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') do
+        val = ENV['VAL']
+      end
+      expect(val).to eq 'something'
+    end
+
+    it "doesn't modify values that were not modified by the passed hash" do
+      origpath = ENV['PATH']
+      path = nil
+      described_class.withenv('VAL' => 'something') do
+        path = ENV['PATH']
+      end
+      expect(path).to eq origpath
+    end
+
+    it "removes new values after the block" do
+      val = nil
+      described_class.withenv('VAL' => 'something') { }
+      expect(ENV['VAL']).to be_nil
+    end
+
+    it "restores old values after the block" do
+      path = ENV['PATH']
+      described_class.withenv('PATH' => '/usr/bin') { }
+      expect(ENV['PATH']).to eq path
+    end
+  end
+
+  describe "reset" do
+
+    after { ENV.delete('VAL') }
+
+    it "replaces environment keys with the specified keys" do
+      ENV['VAL'] = 'hi'
+
+      newenv = ENV.to_hash
+      newenv['VAL'] = 'bye'
+
+      described_class.reset(newenv)
+      expect(ENV['VAL']).to eq 'bye'
+    end
+
+    it "removes any keys that were not provided" do
+      env = ENV.to_hash
+      ENV['VAL'] = 'hi'
+      described_class.reset(env)
+      expect(ENV['VAL']).to be_nil
+    end
+  end
+end

data/spec/unit/util/purgeable_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+require 'r10k/util/purgeable'
+require 'r10k/util/cleaner'
+
+RSpec.describe R10K::Util::Purgeable do
+  let(:managed_directories) do
+    [
+      'spec/fixtures/unit/util/purgeable/managed_one',
+      'spec/fixtures/unit/util/purgeable/managed_two',
+    ]
+  end
+
+  let(:desired_contents) do
+    [
+      'spec/fixtures/unit/util/purgeable/managed_one/expected_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/new_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_symlink_dir',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1/subdir_expected_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1/subdir_new_1',
+      'spec/fixtures/unit/util/purgeable/managed_one/managed_subdir_1/managed_symlink_file',
+      'spec/fixtures/unit/util/purgeable/managed_two/expected_2',
+      'spec/fixtures/unit/util/purgeable/managed_two/new_2',
+      'spec/fixtures/unit/util/purgeable/managed_two/.hidden',
+    ]
+  end
+
+  subject { R10K::Util::Cleaner.new(managed_directories, desired_contents) }
+
+  context 'without recurse option' do
+    let(:recurse) { false }
+
+    describe '#current_contents' do
+      it 'collects direct contents of all managed directories' do
+        expect(subject.current_contents(recurse)).to contain_exactly(/\/expected_1/, /\/expected_2/, /\/unmanaged_1/, /\/unmanaged_2/,
+                                                                     /\/managed_subdir_1/, /\/managed_symlink_dir/, /\/unmanaged_symlink_file/)
+      end
+    end
+
+    describe '#pending_contents' do
+      it 'collects desired_contents that do not yet exist' do
+        expect(subject.pending_contents(recurse)).to include(/\/new_1/, /\/new_2/)
+      end
+    end
+
+    describe '#stale_contents' do
+      context 'with no whitelist or exclusions' do
+        let(:exclusions) { [] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist' do
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/, /\/unmanaged_2/, /\/unmanaged_symlink_file/)
+        end
+      end
+
+      context 'with whitelisted items' do
+        let(:exclusions) { [] }
+        let(:whitelist) { ['**/unmanaged_1'] }
+
+        it 'collects current_contents that should not exist except whitelisted items' do
+          expect(subject.logger).to receive(:debug).with(/unmanaged_1.*whitelist match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_2/, /\/unmanaged_symlink_file/)
+        end
+      end
+
+      context 'with excluded items' do
+        let(:exclusions) { ['**/unmanaged_2'] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist except excluded items' do
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_2.*internal exclusion match/i)
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).to contain_exactly(/\/unmanaged_1/, /\/unmanaged_symlink_file/)
+        end
+      end
+    end
+
+    describe '#purge!' do
+      let(:exclusions) { [] }
+      let(:whitelist) { [] }
+      let(:purge_opts) { { recurse: recurse, whitelist: whitelist } }
+
+      it 'does nothing when there is no stale_contents' do
+        allow(subject).to receive(:stale_contents).and_return([])
+
+        expect(FileUtils).to_not receive(:rm_rf)
+
+        subject.purge!(purge_opts)
+      end
+
+      it 'recursively deletes all stale_contents' do
+        subject.stale_contents(recurse, exclusions, whitelist).each do |stale|
+          expect(FileUtils).to receive(:rm_r).with(stale, hash_including(secure: true))
+        end
+
+        subject.purge!(purge_opts)
+      end
+    end
+  end
+
+  context 'with recurse option' do
+    let(:recurse) { true }
+
+    describe '#current_contents' do
+      it 'collects contents of all managed directories recursively' do
+        expect(subject.current_contents(recurse)).
+          to contain_exactly(/\/expected_1/, /\/expected_2/,
+                             /\/unmanaged_1/, /\/unmanaged_2/,
+                             /\/managed_symlink_dir/,
+                             /\/unmanaged_symlink_file/,
+                             /\/managed_subdir_1/,
+                             /\/subdir_expected_1/, /\/subdir_unmanaged_1/,
+                             /\/managed_symlink_file/,
+                             /\/unmanaged_symlink_dir/,
+                             /\/subdir_allowlisted_2/, /\/ignored_1/,
+                             /\/\.hidden/)
+      end
+    end
+
+    describe '#pending_contents' do
+      it 'collects desired_contents that do not yet exist recursively' do
+        expect(subject.pending_contents(recurse)).to include(/\/new_1/, /\/new_2/, /\/subdir_new_1/)
+      end
+    end
+
+    describe '#stale_contents' do
+      context 'with no whitelist or exclusions' do
+        let(:exclusions) { [] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist recursively' do
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).
+            to contain_exactly(/\/unmanaged_1/, /\/unmanaged_2/, /\/unmanaged_symlink_file/, /\/subdir_unmanaged_1/,
+                               /\/ignored_1/, /\/subdir_allowlisted_2/, /\/unmanaged_symlink_dir/)
+        end
+      end
+
+      context 'with whitelisted items' do
+        let(:exclusions) { [] }
+        let(:whitelist) { ['**/unmanaged_1'] }
+
+        it 'collects current_contents that should not exist except whitelisted items' do
+          expect(subject.logger).to receive(:debug).with(/unmanaged_1.*whitelist match/i)
+
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).
+            to contain_exactly(/\/unmanaged_2/, /\/subdir_unmanaged_1/, /\/unmanaged_symlink_file/, /\/ignored_1/,
+                               /\/subdir_allowlisted_2/, /\/unmanaged_symlink_dir/)
+        end
+
+        it 'does not collect contents that match recursive globbed whitelist items as intermediate values' do
+          recursive_whitelist = ['**/managed_subdir_1/**/*']
+          expect(subject.logger).not_to receive(:debug).with(/ignored_1/)
+
+          expect(subject.stale_contents(recurse, exclusions, recursive_whitelist)).
+            to contain_exactly(/\/unmanaged_2/, /\/managed_one\/unmanaged_1/, /\/managed_one\/unmanaged_symlink_file/)
+        end
+      end
+
+      context 'with excluded items' do
+        let(:exclusions) { ['**/unmanaged_2'] }
+        let(:whitelist) { [] }
+
+        it 'collects current_contents that should not exist except excluded items' do
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_2.*internal exclusion match/i)
+
+          expect(subject.stale_contents(recurse, exclusions, whitelist)).
+            to contain_exactly(/\/unmanaged_1/, /\/unmanaged_symlink_file/, /\/subdir_unmanaged_1/, /\/ignored_1/,
+                               /\/subdir_allowlisted_2/, /\/unmanaged_symlink_dir/)
+        end
+
+        it 'does not collect contents that match recursive globbed exclusion items as intermediate values' do
+          recursive_exclusions = ['**/managed_subdir_1/**/*']
+          expect(subject.logger).not_to receive(:debug).with(/ignored_1/)
+
+          expect(subject.stale_contents(recurse, recursive_exclusions, whitelist)).
+            to contain_exactly(/\/unmanaged_2/, /\/unmanaged_symlink_file/, /\/managed_one\/unmanaged_1/)
+        end
+      end
+    end
+
+    describe '#purge!' do
+      let(:exclusions) { [] }
+      let(:whitelist) { [] }
+      let(:purge_opts) { { recurse: recurse, whitelist: whitelist } }
+
+      it 'does nothing when there is no stale_contents' do
+        allow(subject).to receive(:stale_contents).and_return([])
+
+        expect(FileUtils).to_not receive(:rm_r)
+
+        subject.purge!(purge_opts)
+      end
+
+      it 'recursively deletes all stale_contents' do
+        subject.stale_contents(recurse, exclusions, whitelist).each do |stale|
+          expect(FileUtils).to receive(:rm_r).with(stale, hash_including(secure: true))
+        end
+
+        subject.purge!(purge_opts)
+      end
+    end
+  end
+
+  describe "user whitelist functionality" do
+    context "non-recursive whitelist glob" do
+      let(:whitelist) { managed_directories.collect { |dir| File.join(dir, "*unmanaged*") } }
+      let(:purge_opts) { { recurse: true, whitelist: whitelist } }
+
+      describe '#purge!' do
+        it 'does not purge items matching glob at root level' do
+          allow(FileUtils).to receive(:rm_r)
+          expect(FileUtils).to_not receive(:rm_r).with(/\/unmanaged_[12]/, anything)
+          expect(FileUtils).to_not receive(:rm_r).with(/\/unmanaged_symlink_file/, anything)
+          expect(subject.logger).to receive(:debug).with(/whitelist match/i).at_least(:once)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+
+    context "recursive whitelist glob" do
+      let(:whitelist) do
+        managed_directories.flat_map do |dir|
+          [File.join(dir, "**", "*unmanaged*"), File.join(dir, "**", "subdir_allowlisted_2")]
+        end
+      end
+      let(:purge_opts) { { recurse: true, whitelist: whitelist } }
+
+      describe '#purge!' do
+        it 'does not purge items matching glob at any level' do
+          expect(FileUtils).to_not receive(:rm_r)
+          expect(subject.logger).to receive(:debug).with(/whitelist match/i).at_least(:once)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+  end
+
+  describe "internal exclusions functionality" do
+    let(:purge_opts) { { recurse: true, whitelist: [] } }
+    let(:exclusions) { [ File.join('**', 'unmanaged_1') ] }
+
+    context "when class implements #purge_exclusions" do
+      describe '#purge!' do
+        it 'does not purge items matching exclusion glob' do
+          expect(subject).to receive(:purge_exclusions).and_return(exclusions)
+
+          allow(FileUtils).to receive(:rm_r)
+          expect(FileUtils).to_not receive(:rm_r).with(/\/unmanaged_1/, anything)
+          expect(subject.logger).to receive(:debug2).with(/unmanaged_1.*internal exclusion match/i)
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+
+    context "when class does not implement #purge_exclusions" do
+      describe '#purge!' do
+        it 'purges normally' do
+          expect(FileUtils).to receive(:rm_r).at_least(4).times
+
+          subject.purge!(purge_opts)
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/setopts_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'r10k/util/setopts'
+
+describe R10K::Util::Setopts do
+  let(:klass) do
+    Class.new do
+      include R10K::Util::Setopts
+
+      attr_reader :valid, :alsovalid, :truthyvalid
+
+      def initialize(opts = {})
+        setopts(opts, {
+          :valid => :self,
+          :duplicate => :valid,
+          :alsovalid => :self,
+          :truthyvalid => true,
+          :validalias => :valid,
+          :ignoreme => nil
+        })
+      end
+    end
+  end
+
+  it "can handle an empty hash of options" do
+    o = klass.new()
+    expect(o.valid).to be_nil
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle a single valid option" do
+    o = klass.new(:valid => 'yep')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle multiple valid options" do
+    o = klass.new(:valid => 'yep', :alsovalid => 'yarp')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to eq 'yarp'
+  end
+
+  it "can handle options marked with TrueClass" do
+    o = klass.new(:truthyvalid => 'so truthy')
+    expect(o.truthyvalid).to eq 'so truthy'
+  end
+
+  it "can handle aliases marked with :self" do
+    o = klass.new(:validalias => 'yuuup')
+    expect(o.valid).to eq 'yuuup'
+  end
+
+
+  it "raises an error when given an unhandled option" do
+    expect {
+      klass.new(:valid => 'yep', :notvalid => 'newp')
+    }.to raise_error(ArgumentError, /cannot handle option 'notvalid'/)
+  end
+
+  it "warns when given an unhandled option and raise_on_unhandled=false" do
+    test = Class.new { include R10K::Util::Setopts }.new
+    allow(test).to receive(:logger).and_return(spy)
+
+    test.send(:setopts, {valid: :value, invalid: :value},
+                        {valid: :self},
+                        raise_on_unhandled: false)
+
+    expect(test.logger).to have_received(:warn).with(%r{cannot handle option 'invalid'})
+  end
+
+  it "ignores values that are marked as unhandled" do
+    klass.new(:ignoreme => "IGNORE ME!")
+  end
+
+  it "warns when given conflicting options" do
+    test = Class.new { include R10K::Util::Setopts }.new
+    allow(test).to receive(:logger).and_return(spy)
+
+    test.send(:setopts, {valid: :one, duplicate: :two},
+                        {valid: :arg, duplicate: :arg})
+
+    expect(test.logger).to have_received(:warn).with(%r{valid.*duplicate.*conflict.*not both})
+  end
+end