puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -5,7 +5,7 @@ require 'puppet_spec/module_tool/stub_source'
 
 require 'tmpdir'
 
-describe Puppet::ModuleTool::Applications::Installer do
+describe Puppet::ModuleTool::Applications::Installer, :unless => RUBY_PLATFORM == 'java' do
   include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
   include PuppetSpec::Fixtures
@@ -21,21 +21,22 @@ describe Puppet::ModuleTool::Applications::Installer do
   let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
 
   let(:install_dir) do
-    dir = double("Puppet::ModuleTool::InstallDirectory")
-    allow(dir).to receive(:prepare)
-    allow(dir).to receive(:target).and_return(primary_dir)
-    dir
+    mock("Puppet::ModuleTool::InstallDirectory").tap do |dir|
+      dir.stubs(:prepare)
+      dir.stubs(:target).returns(primary_dir)
+    end
   end
 
   before do
     SemanticPuppet::Dependency.clear_sources
-    allow_any_instance_of(Puppet::ModuleTool::Applications::Installer).to receive(:module_repository).and_return(remote_source)
+    installer = Puppet::ModuleTool::Applications::Installer.any_instance
+    installer.stubs(:module_repository).returns(remote_source)
   end
 
-  if Puppet.features.microsoft_windows?
+  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('installertmp'))
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('installertmp'))
     end
   end
 
@@ -80,7 +81,7 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
 
         it 'installs the specified tarball' do
-          expect(remote_source).not_to receive(:fetch)
+          remote_source.expects(:fetch).never
           expect(subject).to include :result => :success
           graph_should_include 'puppetlabs-stdlib', nil => v('3.2.0')
         end
@@ -101,7 +102,7 @@ describe Puppet::ModuleTool::Applications::Installer do
           end
 
           it 'installs the specified tarball without dependencies' do
-            expect(remote_source).not_to receive(:fetch)
+            remote_source.expects(:fetch).never
             expect(subject).to include :result => :success
             graph_should_include 'puppetlabs-java', nil => v('1.0.0')
             graph_should_include 'puppetlabs-stdlib', nil
@@ -368,7 +369,7 @@ describe Puppet::ModuleTool::Applications::Installer do
 
     context 'when in FIPS mode...' do
       it 'module installer refuses to run' do
-        allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+        Facter.stubs(:value).with(:fips_enabled).returns(true)
         expect {application.run}.to raise_error(/Module install is prohibited in FIPS mode./)
       end 
     end

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

@@ -6,14 +6,14 @@ describe Puppet::ModuleTool::Applications::Searcher do
   include PuppetSpec::Files
 
   describe "when searching" do
-    let(:forge) { double('forge', :host => 'http://nowhe.re') }
+    let(:forge) { mock 'forge', :host => 'http://nowhe.re' }
     let(:searcher) do
       described_class.new('search_term', forge)
     end
 
     it "should return results from a forge query when successful" do
       results = 'mock results'
-      expect(forge).to receive(:search).with('search_term').and_return(results)
+      forge.expects(:search).with('search_term').returns(results)
 
       search_result = searcher.run
       expect(search_result).to eq({
@@ -23,7 +23,7 @@ describe Puppet::ModuleTool::Applications::Searcher do
     end
 
     it "should return an error when the forge query throws an exception" do
-      expect(forge).to receive(:search).with('search_term').and_raise(Puppet::Forge::Errors::ForgeError.new("something went wrong"))
+      forge.expects(:search).with('search_term').raises Puppet::Forge::Errors::ForgeError.new("something went wrong")
 
       search_result = searcher.run
       expect(search_result).to eq({

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

@@ -165,8 +165,9 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
 
   context 'when in FIPS mode...' do
     it 'module uninstaller refuses to run' do
-      allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
+      Facter.stubs(:value).with(:fips_enabled).returns(true)
       expect {application.run}.to raise_error(/Module uninstall is prohibited in FIPS mode/)
     end 
   end
+
 end

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

@@ -14,13 +14,13 @@ describe Puppet::ModuleTool::Applications::Unpacker do
   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)
+    Puppet.settings.stubs(:[])
+    Puppet.settings.stubs(:[]).with(:module_working_dir).returns(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, _|
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, 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')
@@ -28,15 +28,15 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
+    Puppet::ModuleTool::Tar.expects(:instance).returns(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, _|
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, 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')
@@ -46,16 +46,16 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
-    expect(Puppet).to receive(:warning).with(/symlinks/i)
+    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+    Puppet.expects(:warning).with(regexp_matches(/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, _|
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, 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')
@@ -66,8 +66,8 @@ describe Puppet::ModuleTool::Applications::Unpacker do
       true
     end
 
-    expect(Puppet::ModuleTool::Tar).to receive(:instance).and_return(untar)
-    expect(Puppet).to receive(:warning).with(/symlinks/i)
+    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+    Puppet.expects(:warning).with(regexp_matches(/symlinks/i))
 
     Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     expect(File).to be_directory(File.join(target, 'mytarball'))

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

@@ -27,13 +27,14 @@ describe Puppet::ModuleTool::Applications::Upgrader do
 
   before do
     SemanticPuppet::Dependency.clear_sources
-    allow_any_instance_of(Puppet::ModuleTool::Applications::Upgrader).to receive(:module_repository).and_return(remote_source)
+    installer = Puppet::ModuleTool::Applications::Upgrader.any_instance
+    installer.stubs(:module_repository).returns(remote_source)
   end
 
-  if Puppet.features.microsoft_windows?
+  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'))
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('upgradertmp'))
     end
   end
 
@@ -326,10 +327,9 @@ describe Puppet::ModuleTool::Applications::Upgrader do
         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)
+        Facter.stubs(:value).with(:fips_enabled).returns(true)
         expect { application.run }.to raise_error(/Module upgrade is prohibited in FIPS mode/)
       end 
     end

data/spec/unit/module_tool/install_directory_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   it "(#15202) creates the install directory" do
     target_dir = the_directory('foo', :directory? => false, :exist? => false)
-    expect(target_dir).to receive(:mkpath)
+    target_dir.expects(:mkpath)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -21,7 +21,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   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)
+    target_dir.expects(:mkpath).raises(Errno::EACCES)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -34,7 +34,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   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)
+    target_dir.expects(:mkpath).raises(Errno::EEXIST)
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -45,7 +45,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   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")
+    target_dir.expects(:mkpath).raises("unknown error")
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -54,7 +54,7 @@ describe Puppet::ModuleTool::InstallDirectory do
 
   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")
+    target_dir.expects(:mkpath).raises(SystemCallError, "unknown")
 
     install = Puppet::ModuleTool::InstallDirectory.new(target_dir)
 
@@ -62,9 +62,9 @@ describe Puppet::ModuleTool::InstallDirectory do
   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 = mock("Pathname<#{name}>")
+    dir.stubs(:exist?).returns(options.fetch(:exist?, true))
+    dir.stubs(:directory?).returns(options.fetch(:directory?, true))
     dir
   end
 end

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -24,14 +24,14 @@ describe Puppet::ModuleTool::InstalledModules do
 
   it 'defaults when not given a semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/)
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'defaults when not given a full semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/)
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
@@ -40,7 +40,7 @@ describe Puppet::ModuleTool::InstalledModules do
     mod1 = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
     mod2 = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
     mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
-    expect(Puppet).to receive(:warning).with(/Semantic Version/).twice
+    Puppet.expects(:warning).with(regexp_matches(/Semantic Version/)).twice
     installed = described_class.new(@env)
     expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
     expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -8,16 +8,16 @@ describe Puppet::ModuleTool::Tar::Gnu do
   let(:destfile)   { '/space path/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    expect(Dir).to receive(:chdir).with(File.expand_path(destdir)).and_yield
-    expect(Puppet::Util::Execution).to receive(:execute).with("gzip -dc #{Shellwords.shellescape(File.expand_path(sourcefile))} | tar xof -")
-    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type d -exec chmod 755 {} +")
-    expect(Puppet::Util::Execution).to receive(:execute).with("find . -type f -exec chmod u+rw,g+r,a-st {} +")
-    expect(Puppet::Util::Execution).to receive(:execute).with("chown -R <owner:group> .")
+    Dir.expects(:chdir).with(File.expand_path(destdir)).yields(mock)
+    Puppet::Util::Execution.expects(:execute).with("gzip -dc #{Shellwords.shellescape(File.expand_path(sourcefile))} | tar xof -")
+    Puppet::Util::Execution.expects(:execute).with("find . -type d -exec chmod 755 {} +")
+    Puppet::Util::Execution.expects(:execute).with("find . -type f -exec chmod u+rw,g+r,a-st {} +")
+    Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> .")
     subject.unpack(sourcefile, destdir, '<owner:group>')
   end
 
   it "packs a tar file" do
-    expect(Puppet::Util::Execution).to receive(:execute).with("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
+    Puppet::Util::Execution.expects(:execute).with("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
     subject.pack(sourcedir, destfile)
   end
 end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -57,33 +57,33 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   end
 
   it "packs a tar file" do
-    writer = double('GzipWriter')
+    writer = stub('GzipWriter')
 
-    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
+    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
     stats = {:mode => 0222}
-    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).and_yield(:file_start, 'abc', stats)
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).yields(:file_start, 'abc', stats)
 
     minitar.pack(sourcedir, destfile)
   end
 
   it "packs a tar file on Windows" do
-    writer = double('GzipWriter')
+    writer = stub('GzipWriter')
 
-    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
-    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer).
-        and_yield(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
+    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).
+        yields(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
 
     minitar.pack(sourcedir, destfile)
   end
 
   def unpacks_the_entry(type, name, mode = 0100)
-    reader = double('GzipReader')
+    reader = stub('GzipReader')
 
-    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
-    expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
+    Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
+    minitar.expects(:find_valid_files).with(reader).returns([name])
     entry = MockFileStatEntry.new(mode)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], :fsync => false).
-        and_yield(type, name, {:entry => entry})
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).
+        yields(type, name, {:entry => entry})
     entry
   end
 end

data/spec/unit/module_tool/tar_spec.rb

@@ -2,34 +2,35 @@ require 'spec_helper'
 require 'puppet/module_tool/tar'
 
 describe Puppet::ModuleTool::Tar do
+
   [
     { :name => 'ObscureLinuxDistro', :win => false }, 
     { :name => 'Windows', :win => true }
   ].each do |os|
     it "always prefers minitar if it and zlib are present, even with tar available" do
-      allow(Facter).to receive(:value).with('osfamily').and_return(os[:name])
-      allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
-      allow(Puppet::Util::Platform).to receive(:windows?).and_return(os[:win])
-      allow(Puppet).to receive(:features).and_return(double(:minitar? => true, :zlib? => true))
+      Facter.stubs(:value).with('osfamily').returns os[:name]
+      Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
+      Puppet::Util::Platform.stubs(:windows?).returns os[:win]
+      Puppet.stubs(:features).returns(stub(:minitar? => true, :zlib? => true))
 
       expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Mini
     end
   end
 
   it "falls back to tar when minitar not present and not on Windows" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('ObscureLinuxDistro')
-    allow(Puppet::Util).to receive(:which).with('tar').and_return('/usr/bin/tar')
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-    allow(Puppet).to receive(:features).and_return(double(:minitar? => false))
+    Facter.stubs(:value).with('osfamily').returns 'ObscureLinuxDistro'
+    Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
+    Puppet::Util::Platform.stubs(:windows?).returns false
+    Puppet.stubs(:features).returns(stub(:minitar? => false))
 
     expect(described_class.instance).to be_a_kind_of Puppet::ModuleTool::Tar::Gnu
   end
 
   it "fails when there is no possible implementation" do
-    allow(Facter).to receive(:value).with('osfamily').and_return('Windows')
-    allow(Puppet::Util).to receive(:which).with('tar')
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
-    allow(Puppet).to receive(:features).and_return(double(:minitar? => false, :zlib? => false))
+    Facter.stubs(:value).with('osfamily').returns 'Windows'
+    Puppet::Util.stubs(:which).with('tar')
+    Puppet::Util::Platform.stubs(:windows?).returns true
+    Puppet.stubs(:features).returns(stub(:minitar? => false, :zlib? => false))
 
     expect { described_class.instance }.to raise_error RuntimeError, /No suitable tar/
   end

data/spec/unit/module_tool_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 # encoding: UTF-8
 
 require 'spec_helper'
@@ -6,13 +7,15 @@ require 'puppet/module_tool'
 describe Puppet::ModuleTool do
   describe '.is_module_root?' do
     it 'should return true if directory has a metadata.json file' do
-      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(true)
+      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
+        returns(true)
 
       expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_truthy
     end
 
     it 'should return false if directory does not have a metadata.json file' do
-      expect(FileTest).to receive(:file?).with(have_attributes(to_s: '/a/b/c/metadata.json')).and_return(false)
+      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
+        returns(false)
 
       expect(subject.is_module_root?(Pathname.new('/a/b/c'))).to be_falsey
     end
@@ -22,21 +25,23 @@ describe Puppet::ModuleTool do
     let(:sample_path) { Pathname.new('/a/b/c').expand_path }
 
     it 'should return the first path as a pathname when it contains a module file' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(sample_path).
-        and_return(true)
+      Puppet::ModuleTool.expects(:is_module_root?).with(sample_path).
+        returns(true)
 
       expect(subject.find_module_root(sample_path)).to eq(sample_path)
     end
 
     it 'should return a parent path as a pathname when it contains a module file' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b/c'))).and_return(false)
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).with(have_attributes(to_s: File.expand_path('/a/b'))).and_return(true)
+      Puppet::ModuleTool.expects(:is_module_root?).
+        with(responds_with(:to_s, File.expand_path('/a/b/c'))).returns(false)
+      Puppet::ModuleTool.expects(:is_module_root?).
+        with(responds_with(:to_s, File.expand_path('/a/b'))).returns(true)
 
       expect(subject.find_module_root(sample_path)).to eq(Pathname.new('/a/b').expand_path)
     end
 
     it 'should return nil when no module root can be found' do
-      expect(Puppet::ModuleTool).to receive(:is_module_root?).at_least(:once).and_return(false)
+      Puppet::ModuleTool.expects(:is_module_root?).at_least_once.returns(false)
       expect(subject.find_module_root(sample_path)).to be_nil
     end
   end
@@ -224,28 +229,6 @@ TREE
       end
     end
 
-    describe ':strict_semver' do
-      context 'when set' do
-        let(:options) do
-          { :strict_semver => true }
-        end
-
-        it 'is not overridden by default' do
-          expect(subject).to include :strict_semver => true
-        end
-      end
-
-      context 'when unset' do
-        let(:options) do
-          { }
-        end
-
-        it 'defaults to false' do
-          expect(subject).to include :strict_semver => false
-        end
-      end
-    end
-
     describe ':target_dir' do
       let(:options) do
         { :target_dir => 'foo' }