puppet 7.34.0-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/module_tool/applications/uninstaller_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+require 'tmpdir'
+require 'puppet_spec/module_tool/shared_functions'
+require 'puppet_spec/module_tool/stub_source'
+
+describe Puppet::ModuleTool::Applications::Uninstaller do
+  include PuppetSpec::ModuleTool::SharedFunctions
+  include PuppetSpec::Files
+
+  before do
+    FileUtils.mkdir_p(primary_dir)
+    FileUtils.mkdir_p(secondary_dir)
+  end
+
+  let(:environment) do
+    Puppet.lookup(:current_environment).override_with(
+      :vardir     => vardir,
+      :modulepath => [ primary_dir, secondary_dir ]
+    )
+  end
+
+  let(:vardir)   { tmpdir('uninstaller') }
+  let(:primary_dir) { File.join(vardir, "primary") }
+  let(:secondary_dir) { File.join(vardir, "secondary") }
+  let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
+
+  let(:module) { 'module-not_installed' }
+  let(:application) do
+    opts = options
+    Puppet::ModuleTool.set_option_defaults(opts)
+    Puppet::ModuleTool::Applications::Uninstaller.new(self.module, opts)
+  end
+
+  def options
+    { :environment => environment }
+  end
+
+  subject { application.run }
+
+  context "when the module is not installed" do
+    it "should fail" do
+      expect(subject).to include :result => :failure
+    end
+  end
+
+  context "when the module is installed" do
+    let(:module) { 'pmtacceptance-stdlib' }
+
+    before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+    before { preinstall('pmtacceptance-apache', '0.0.4') }
+
+    it "should uninstall the module" do
+      expect(subject[:affected_modules].first.forge_name).to eq("pmtacceptance/stdlib")
+    end
+
+    it "should only uninstall the requested module" do
+      subject[:affected_modules].length == 1
+    end
+
+    it 'should refuse to uninstall in FIPS mode' do
+      allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+      err = subject[:error][:oneline]
+      expect(err).to eq("Either the `--ignore_changes` or `--force` argument must be specified to uninstall modules when running in FIPS mode.")
+    end
+
+    context 'in two modulepaths' do
+      before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
+
+      it "should fail if a module exists twice in the modpath" do
+        expect(subject).to include :result => :failure
+      end
+    end
+
+    context "when options[:version] is specified" do
+      def options
+        super.merge(:version => '1.0.0')
+      end
+
+      it "should uninstall the module if the version matches" do
+        expect(subject[:affected_modules].length).to eq(1)
+        expect(subject[:affected_modules].first.version).to eq("1.0.0")
+      end
+
+      context 'but not matched' do
+        def options
+          super.merge(:version => '2.0.0')
+        end
+
+        it "should not uninstall the module if the version does not match" do
+          expect(subject).to include :result => :failure
+        end
+      end
+    end
+
+    context "when the module metadata is missing" do
+      before { File.unlink(File.join(primary_dir, 'stdlib', 'metadata.json')) }
+
+      it "should not uninstall the module" do
+        expect(application.run[:result]).to eq(:failure)
+      end
+    end
+
+    context "when the module has local changes" do
+      before do
+        mark_changed(File.join(primary_dir, 'stdlib'))
+      end
+
+      it "should not uninstall the module" do
+        expect(subject).to include :result => :failure
+      end
+    end
+
+    context "when uninstalling the module will cause broken dependencies" do
+      before { preinstall('pmtacceptance-apache', '0.10.0') }
+
+      it "should not uninstall the module" do
+        expect(subject).to include :result => :failure
+      end
+    end
+
+    context 'with --ignore-changes' do
+      def options
+        super.merge(:ignore_changes => true)
+      end
+
+      context 'with local changes' do
+        before do
+          mark_changed(File.join(primary_dir, 'stdlib'))
+        end
+
+        it 'overwrites the installed module with the greatest version matching that range' do
+          expect(subject).to include :result => :success
+        end
+
+        it 'uninstalls in FIPS mode' do
+          allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+          expect(subject).to include :result => :success
+        end
+      end
+
+      context 'without local changes' do
+        it 'overwrites the installed module with the greatest version matching that range' do
+          expect(subject).to include :result => :success
+        end
+      end
+    end
+
+    context "when using the --force flag" do
+
+      def options
+        super.merge(:force => true)
+      end
+
+      context "with local changes" do
+        before do
+          mark_changed(File.join(primary_dir, 'stdlib'))
+        end
+
+        it "should ignore local changes" do
+          expect(subject[:affected_modules].length).to eq(1)
+          expect(subject[:affected_modules].first.forge_name).to eq("pmtacceptance/stdlib")
+        end
+
+        it 'uninstalls in FIPS mode' do
+          allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+          expect(subject).to include :result => :success
+        end
+      end
+
+      context "while depended upon" do
+        before { preinstall('pmtacceptance-apache', '0.10.0') }
+
+        it "should ignore broken dependencies" do
+          expect(subject[:affected_modules].length).to eq(1)
+          expect(subject[:affected_modules].first.forge_name).to eq("pmtacceptance/stdlib")
+        end
+      end
+    end
+  end
+end

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'puppet/util/json'
+
+require 'puppet/module_tool/applications'
+require 'puppet/file_system'
+require 'puppet_spec/modules'
+
+describe Puppet::ModuleTool::Applications::Unpacker do
+  include PuppetSpec::Files
+
+  let(:target)      { tmpdir("unpacker") }
+  let(:module_name) { 'myusername-mytarball' }
+  let(:filename)    { tmpdir("module") + "/module.tar.gz" }
+  let(:working_dir) { tmpdir("working_dir") }
+
+  before :each do
+    allow(Puppet.settings).to receive(:[])
+    allow(Puppet.settings).to receive(:[]).with(:module_working_dir).and_return(working_dir)
+  end
+
+  it "should attempt to untar file to temporary location" do
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
+      end
+      true
+    end
+
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
+    expect(File).to be_directory(File.join(target, 'mytarball'))
+  end
+
+  it "should warn about symlinks", :if => Puppet.features.manages_symlinks? do
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
+      end
+      FileUtils.touch(File.join(dest, 'extractedmodule/tempfile'))
+      Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/tempfile'), File.join(dest, 'extractedmodule/tempfile2'))
+      true
+    end
+
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+    expect(Puppet).to receive(:warning).with(/symlinks/i)
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
+    expect(File).to be_directory(File.join(target, 'mytarball'))
+  end
+
+  it "should warn about symlinks in subdirectories", :if => Puppet.features.manages_symlinks? do
+    untar = double('Tar')
+    expect(untar).to receive(:unpack).with(filename, anything, anything) do |src, dest, _|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts Puppet::Util::Json.dump('name' => module_name, 'version' => '1.0.0')
+      end
+      FileUtils.mkdir(File.join(dest, 'extractedmodule/manifests'))
+      FileUtils.touch(File.join(dest, 'extractedmodule/manifests/tempfile'))
+      Puppet::FileSystem.symlink(File.join(dest, 'extractedmodule/manifests/tempfile'), File.join(dest, 'extractedmodule/manifests/tempfile2'))
+      true
+    end
+
+    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+    expect(Puppet).to receive(:warning).with(/symlinks/i)
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
+    expect(File).to be_directory(File.join(target, 'mytarball'))
+  end
+end

data/spec/unit/module_tool/applications/upgrader_spec.rb

@@ -0,0 +1,337 @@
+require 'spec_helper'
+require 'puppet/module_tool/applications'
+require 'puppet_spec/module_tool/shared_functions'
+require 'puppet_spec/module_tool/stub_source'
+require 'tmpdir'
+
+describe Puppet::ModuleTool::Applications::Upgrader do
+  include PuppetSpec::ModuleTool::SharedFunctions
+  include PuppetSpec::Files
+
+  before do
+    FileUtils.mkdir_p(primary_dir)
+    FileUtils.mkdir_p(secondary_dir)
+  end
+
+  let(:vardir)   { tmpdir('upgrader') }
+  let(:primary_dir) { File.join(vardir, "primary") }
+  let(:secondary_dir) { File.join(vardir, "secondary") }
+  let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
+
+  let(:environment) do
+    Puppet.lookup(:current_environment).override_with(
+      :vardir     => vardir,
+      :modulepath => [ primary_dir, secondary_dir ]
+    )
+  end
+
+  before do
+    SemanticPuppet::Dependency.clear_sources
+    allow_any_instance_of(Puppet::ModuleTool::Applications::Upgrader).to receive(:module_repository).and_return(remote_source)
+  end
+
+  if Puppet::Util::Platform.windows?
+    before :each do
+      allow(Puppet.settings).to receive(:[])
+      allow(Puppet.settings).to receive(:[]).with(:module_working_dir).and_return(Dir.mktmpdir('upgradertmp'))
+    end
+  end
+
+  def upgrader(name, options = {})
+    Puppet::ModuleTool.set_option_defaults(options)
+    Puppet::ModuleTool::Applications::Upgrader.new(name, options)
+  end
+
+  describe '#run' do
+    let(:module) { 'pmtacceptance-stdlib' }
+
+    def options
+      { :environment => environment }
+    end
+
+    let(:application) { upgrader(self.module, options) }
+    subject { application.run }
+
+    it 'fails if the module is not already installed' do
+      expect(subject).to include :result => :failure
+      expect(subject[:error]).to include :oneline => "Could not upgrade '#{self.module}'; module is not installed"
+    end
+
+    context 'for an installed module' do
+      context 'with only one version' do
+        before { preinstall('puppetlabs-oneversion', '0.0.1') }
+        let(:module) { 'puppetlabs-oneversion' }
+
+        it 'declines to upgrade' do
+          expect(subject).to include :result => :noop
+          expect(subject[:error][:multiline]).to match(/already the latest version/)
+        end
+      end
+
+      context 'without dependencies' do
+        before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+
+        context 'without options' do
+          it 'properly upgrades the module to the greatest version' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+          end
+        end
+
+        context 'with version range' do
+          def options
+            super.merge(:version => '3.x')
+          end
+
+          context 'not matching the installed version' do
+            it 'properly upgrades the module to the greatest version within that range' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('3.2.0')
+            end
+          end
+
+          context 'matching the installed version' do
+            context 'with more recent version' do
+              before { preinstall('pmtacceptance-stdlib', '3.0.0')}
+
+              it 'properly upgrades the module to the greatest version within that range' do
+                expect(subject).to include :result => :success
+                graph_should_include 'pmtacceptance-stdlib', v('3.0.0') => v('3.2.0')
+              end
+            end
+
+            context 'without more recent version' do
+              before { preinstall('pmtacceptance-stdlib', '3.2.0')}
+
+              context 'without options' do
+                it 'declines to upgrade' do
+                  expect(subject).to include :result => :noop
+                  expect(subject[:error][:multiline]).to match(/already the latest version/)
+                end
+              end
+
+              context 'with --force' do
+                def options
+                  super.merge(:force => true)
+                end
+
+                it 'overwrites the installed module with the greatest version matching that range' do
+                  expect(subject).to include :result => :success
+                  graph_should_include 'pmtacceptance-stdlib', v('3.2.0') => v('3.2.0')
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context 'that is depended upon' do
+        # pmtacceptance-keystone depends on pmtacceptance-mysql  >=0.6.1 <1.0.0
+        before { preinstall('pmtacceptance-keystone', '2.1.0') }
+        before { preinstall('pmtacceptance-mysql', '0.9.0') }
+
+        let(:module) { 'pmtacceptance-mysql' }
+
+        context 'and out of date' do
+          before { preinstall('pmtacceptance-mysql', '0.8.0') }
+
+          it 'properly upgrades to the greatest version matching the dependency' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-mysql', v('0.8.0') => v('0.9.0')
+          end
+        end
+
+        context 'and up to date' do
+          it 'declines to upgrade' do
+            expect(subject).to include :result => :failure
+          end
+        end
+
+        context 'when specifying a violating version range' do
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to upgrade the module' do
+            # TODO: More helpful error message?
+            expect(subject).to include :result => :failure
+            expect(subject[:error]).to include :oneline => "Could not upgrade '#{self.module}' (v0.9.0 -> v2.1.0); no version satisfies all dependencies"
+          end
+
+          context 'using --force' do
+            def options
+              super.merge(:force => true)
+            end
+
+            it 'overwrites the installed module with the specified version' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-mysql', v('0.9.0') => v('2.1.0')
+            end
+          end
+        end
+      end
+
+      context 'with local changes' do
+        before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+        before do
+          release = application.send(:installed_modules)['pmtacceptance-stdlib']
+          mark_changed(release.mod.path)
+        end
+
+        it 'fails to upgrade' do
+          expect(subject).to include :result => :failure
+          expect(subject[:error]).to include :oneline => "Could not upgrade '#{self.module}'; module has had changes made locally"
+        end
+
+        context 'with --ignore-changes' do
+          def options
+            super.merge(:ignore_changes => true)
+          end
+
+          it 'overwrites the installed module with the greatest version matching that range' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+          end
+        end
+      end
+
+      context 'with dependencies' do
+        context 'that are unsatisfied' do
+          def options
+            super.merge(:version => '0.1.1')
+          end
+
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module and installs the missing dependencies' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.1.1')
+            graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0'), :action => :install
+          end
+        end
+
+        context 'with older major versions' do
+          # pmtacceptance-apache 0.0.4 has no dependency on pmtacceptance-stdlib
+          # the next available version (0.1.1) and all subsequent versions depend on pmtacceptance-stdlib >= 2.2.1
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'refuses to upgrade the installed dependency to a new major version, but upgrades the module to the greatest compatible version' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.0.4')
+          end
+
+          context 'using --ignore_dependencies' do
+            def options
+              super.merge(:ignore_dependencies => true)
+            end
+
+            it 'upgrades the module to the greatest available version' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            end
+          end
+        end
+
+        context 'with satisfying major versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.0.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module and its dependencies to their greatest compatible versions' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', v('2.0.0') => v('2.6.0')
+          end
+        end
+
+        context 'with satisfying versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.4.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module to the greatest available version' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
+
+        context 'with current versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module to the greatest available version' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
+
+        context 'with shared dependencies' do
+          # bacula 0.0.3 depends on stdlib >= 2.2.0 and pmtacceptance/mysql >= 1.0.0
+          # bacula 0.0.2 depends on stdlib >= 2.2.0 and pmtacceptance/mysql >= 0.0.1
+          # bacula 0.0.1 depends on stdlib >= 2.2.0
+
+          # keystone 2.1.0 depends on pmtacceptance/stdlib >= 2.5.0 and pmtacceptance/mysql >=0.6.1 <1.0.0
+
+          before { preinstall('pmtacceptance-bacula', '0.0.1') }
+          before { preinstall('pmtacceptance-mysql', '0.9.0') }
+          before { preinstall('pmtacceptance-keystone', '2.1.0') }
+
+          let(:module) { 'pmtacceptance-bacula' }
+
+          it 'upgrades the module to the greatest version compatible with all other installed modules' do
+            expect(subject).to include :result => :success
+            graph_should_include 'pmtacceptance-bacula', v('0.0.1') => v('0.0.2')
+          end
+
+          context 'using --force' do
+            def options
+              super.merge(:force => true)
+            end
+
+            it 'upgrades the module to the greatest version available' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-bacula', v('0.0.1') => v('0.0.3')
+            end
+          end
+        end
+
+        context 'in other modulepath directories' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '1.0.0', :into => secondary_dir) }
+          let(:module) { 'pmtacceptance-apache' }
+
+          context 'with older major versions' do
+            it 'upgrades the module to the greatest version compatible with the installed modules' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.0.4')
+              graph_should_include 'pmtacceptance-stdlib', nil
+            end
+          end
+
+          context 'with satisfying major versions' do
+            before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
+
+            it 'upgrades the module and its dependencies to their greatest compatible versions, in-place' do
+              expect(subject).to include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+              graph_should_include 'pmtacceptance-stdlib', v('2.0.0') => v('2.6.0'), :path => secondary_dir
+            end
+          end
+        end
+      end
+    end
+
+    context 'when in FIPS mode...' do
+      it 'module unpgrader refuses to run' do
+        allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+        expect { application.run }.to raise_error(/Module upgrade is prohibited in FIPS mode/)
+      end 
+    end
+  end
+end

data/spec/unit/module_tool/install_directory_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'puppet/module_tool/install_directory'
+
+describe Puppet::ModuleTool::InstallDirectory do
+  def expect_normal_results
+    results = installer.run
+    expect(results[:installed_modules].length).to eq 1
+    expect(results[:installed_modules][0][:module]).to eq("pmtacceptance-stdlib")
+    expect(results[:installed_modules][0][:version][:vstring]).to eq("1.0.0")
+    results
+  end
+
+  it "(#15202) creates the install directory" do
+    target_dir = the_directory('foo', :directory? => false, :exist? => false)
+    expect(target_dir).to receive(:mkpath)
+
+    install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
+
+    install.prepare('pmtacceptance-stdlib', '1.0.0')
+  end
+
+  it "(#15202) errors when the directory is not accessible" do
+    target_dir = the_directory('foo', :directory? => false, :exist? => false)
+    expect(target_dir).to receive(:mkpath).and_raise(Errno::EACCES)
+
+    install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
+
+    expect {
+      install.prepare('module', '1.0.1')
+    }.to raise_error(
+      Puppet::ModuleTool::Errors::PermissionDeniedCreateInstallDirectoryError
+    )
+  end
+
+  it "(#15202) errors when an entry along the path is not a directory" do
+    target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
+    expect(target_dir).to receive(:mkpath).and_raise(Errno::EEXIST)
+
+    install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
+
+    expect {
+      install.prepare('module', '1.0.1')
+    }.to raise_error(Puppet::ModuleTool::Errors::InstallPathExistsNotDirectoryError)
+  end
+
+  it "(#15202) simply re-raises an unknown error" do
+    target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
+    expect(target_dir).to receive(:mkpath).and_raise("unknown error")
+
+    install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
+
+    expect { install.prepare('module', '1.0.1') }.to raise_error("unknown error")
+  end
+
+  it "(#15202) simply re-raises an unknown system call error" do
+    target_dir = the_directory("foo/bar", :exist? => false, :directory? => false)
+    expect(target_dir).to receive(:mkpath).and_raise(SystemCallError, "unknown")
+
+    install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
+
+    expect { install.prepare('module', '1.0.1') }.to raise_error(SystemCallError)
+  end
+
+  def the_directory(name, options)
+    dir = double("Pathname<#{name}>")
+    allow(dir).to receive(:exist?).and_return(options.fetch(:exist?, true))
+    allow(dir).to receive(:directory?).and_return(options.fetch(:directory?, true))
+    dir
+  end
+end