r10k 3.14.1 → 5.0.1

data/spec/unit/util/attempt_spec.rb

@@ -1,82 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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) { 'git://some/git/remote' }
-
-    it 'sanitizes URL to directory name' do
-      expect(subject.sanitized_dirname(input)).to eq('git---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

@@ -1,61 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,267 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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