puppet 5.3.4 → 6.29.0

data/spec/unit/interface/face_collection_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
@@ -55,13 +54,13 @@ describe Puppet::Interface::FaceCollection do
     end
 
     it "should attempt to load the face if it isn't found" do
-      subject.expects(:require).once.with('puppet/face/bar')
-      subject.expects(:require).once.with('puppet/face/0.0.1/bar')
+      expect(subject).to receive(:require).once.with('puppet/face/bar')
+      expect(subject).to receive(:require).once.with('puppet/face/0.0.1/bar')
       subject["bar", '0.0.1']
     end
 
     it "should attempt to load the default face for the specified version :current" do
-      subject.expects(:require).with('puppet/face/fozzie')
+      expect(subject).to receive(:require).with('puppet/face/fozzie')
       subject['fozzie', :current]
     end
 
@@ -71,29 +70,37 @@ describe Puppet::Interface::FaceCollection do
     end
 
     it "should attempt to require the face if it is not registered" do
-      subject.expects(:require).with do |file|
+      expect(subject).to receive(:require) do |file|
         subject.instance_variable_get("@faces")[:bar][SemanticPuppet::Version.parse('0.0.1')] = true
-        file == 'puppet/face/bar'
+        expect(file).to eq('puppet/face/bar')
       end
+
       expect(subject["bar", '0.0.1']).to be_truthy
     end
 
     it "should return false if the face is not registered" do
-      subject.stubs(:require).returns(true)
+      allow(subject).to receive(:require).and_return(true)
       expect(subject["bar", '0.0.1']).to be_falsey
     end
 
     it "should return false if the face file itself is missing" do
-      subject.stubs(:require).
-        raises(LoadError, 'no such file to load -- puppet/face/bar').then.
-        raises(LoadError, 'no such file to load -- puppet/face/0.0.1/bar')
+      num_calls = 0
+      allow(subject).to receive(:require) do
+        num_calls += 1
+        if num_calls == 1
+          raise LoadError.new('no such file to load -- puppet/face/bar')
+        else
+          raise LoadError.new('no such file to load -- puppet/face/0.0.1/bar')
+        end
+      end
+
       expect(subject["bar", '0.0.1']).to be_falsey
     end
 
     it "should register the version loaded by `:current` as `:current`" do
-      subject.expects(:require).with do |file|
+      expect(subject).to receive(:require) do |file|
         subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_face
-        file == 'puppet/face/huzzah'
+        expect(file).to eq('puppet/face/huzzah')
       end
       subject["huzzah", :current]
       expect(subject.instance_variable_get("@faces")[:huzzah][:current]).to eq(:huzzah_face)

data/spec/unit/interface_spec.rb

@@ -61,7 +61,7 @@ describe Puppet::Interface do
     end
 
     it "should load actions" do
-      subject.any_instance.expects(:load_actions)
+      expect_any_instance_of(subject).to receive(:load_actions)
       subject.define(:face_test_load_actions, '0.0.1')
     end
 
@@ -121,8 +121,8 @@ describe Puppet::Interface do
   end
 
   it "should try to require faces that are not known" do
-    subject::FaceCollection.expects(:load_face).with(:foo, :current)
-    subject::FaceCollection.expects(:load_face).with(:foo, '0.0.1')
+    expect(subject::FaceCollection).to receive(:load_face).with(:foo, :current)
+    expect(subject::FaceCollection).to receive(:load_face).with(:foo, '0.0.1')
     expect { subject[:foo, '0.0.1'] }.to raise_error Puppet::Error
   end
 
@@ -180,7 +180,7 @@ describe Puppet::Interface do
           display_global_options "modulepath"
         end
       end
-      face.display_global_options =~ ["environment"]
+      expect(face.display_global_options).to match(["environment"])
     end
 
     it "should not fail when a face d_g_o duplicates an action d_g_o" do
@@ -200,8 +200,8 @@ describe Puppet::Interface do
         action :foo do when_invoked {|_| true} ; display_global_options "environment" end
         action :bar do when_invoked {|_| true} ; display_global_options "environment" end
       end
-      face.get_action(:foo).display_global_options =~ ["environment"]
-      face.get_action(:bar).display_global_options =~ ["environment"]
+      expect(face.get_action(:foo).display_global_options).to match(["environment"])
+      expect(face.get_action(:bar).display_global_options).to match(["environment"])
     end
       
   end

data/spec/unit/module_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
@@ -7,7 +6,7 @@ require 'puppet/module_tool/checksums'
 describe Puppet::Module do
   include PuppetSpec::Files
 
-  let(:env) { mock("environment") }
+  let(:env) { double("environment") }
   let(:path) { "/path" }
   let(:name) { "mymod" }
   let(:mod) { Puppet::Module.new(name, path, env) }
@@ -15,12 +14,12 @@ describe Puppet::Module do
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
-    Puppet::FileSystem.stubs(:exist?).returns false
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = Puppet::Node::Environment.create(:myenv, [])
-    env.expects(:module).with(name).returns "yep"
+    expect(env).to receive(:module).with(name).and_return("yep")
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       expect(Puppet::Module.find(name, "myenv")).to eq("yep")
     end
@@ -28,7 +27,7 @@ describe Puppet::Module do
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = Puppet::Node::Environment.create(:myenv, [])
-    env.expects(:module).with(name).returns nil
+    expect(env).to receive(:module).with(name).and_return(nil)
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       expect(Puppet::Module.find(name, "myenv")).to be_nil
     end
@@ -136,7 +135,7 @@ describe Puppet::Module do
 
   describe "when finding unmet dependencies" do
     before do
-      Puppet::FileSystem.unstub(:exist?)
+      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
@@ -163,13 +162,12 @@ describe Puppet::Module do
         :environment => env
       )
 
-      env.expects(:module_by_forge_name).with('foo/child').returns(child)
+      expect(env).to receive(:module_by_forge_name).with('foo/child').and_return(child)
 
       expect(parent.unmet_dependencies).to eq([])
     end
 
     it "should list modules that are missing" do
-      metadata_file = "#{@modpath}/needy/metadata.json"
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -182,7 +180,7 @@ describe Puppet::Module do
         :environment => env
       )
 
-      env.expects(:module_by_forge_name).with('baz/foobar').returns(nil)
+      expect(env).to receive(:module_by_forge_name).with('baz/foobar').and_return(nil)
 
       expect(mod.unmet_dependencies).to eq([{
         :reason => :missing,
@@ -194,7 +192,6 @@ describe Puppet::Module do
     end
 
     it "should list modules that are missing and have invalid names" do
-      metadata_file = "#{@modpath}/needy/metadata.json"
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -207,7 +204,7 @@ describe Puppet::Module do
         :environment => env
       )
 
-      env.expects(:module_by_forge_name).with('baz/foobar=bar').returns(nil)
+      expect(env).to receive(:module_by_forge_name).with('baz/foobar=bar').and_return(nil)
 
       expect(mod.unmet_dependencies).to eq([{
         :reason => :missing,
@@ -224,9 +221,7 @@ describe Puppet::Module do
       ['test_gte_req', 'test_specific_req', 'foobar'].each do |mod_name|
         mod_dir = "#{@modpath}/#{mod_name}"
         metadata_file = "#{mod_dir}/metadata.json"
-        tasks_dir = "#{mod_dir}/tasks"
-        locale_dir = "#{mod_dir}/locales"
-        Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
+        allow(Puppet::FileSystem).to receive(:exist?).with(metadata_file).and_return(true)
       end
       mod = PuppetSpec::Modules.create(
         'test_gte_req',
@@ -305,7 +300,6 @@ describe Puppet::Module do
     it "should consider a dependency without a semantic version to be unmet" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
-      metadata_file = "#{@modpath}/foobar/metadata.json"
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -484,7 +478,7 @@ describe Puppet::Module do
     end
   end
 
-  [:plugins, :pluginfacts, :templates, :files, :manifests].each do |filetype|
+  [:plugins, :pluginfacts, :templates, :files, :manifests, :scripts].each do |filetype|
     case filetype
       when :plugins
         dirname = "lib"
@@ -493,33 +487,34 @@ describe Puppet::Module do
       else
         dirname = filetype.to_s
     end
+
     it "should be able to return individual #{filetype}" do
       module_file = File.join(path, dirname, "my/file")
-      Puppet::FileSystem.expects(:exist?).with(module_file).returns true
+      expect(Puppet::FileSystem).to receive(:exist?).with(module_file).and_return(true)
       expect(mod.send(filetype.to_s.sub(/s$/, ''), "my/file")).to eq(module_file)
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       module_file = File.join(path, dirname)
-      Puppet::FileSystem.expects(:exist?).with(module_file).returns true
+      expect(Puppet::FileSystem).to receive(:exist?).with(module_file).and_return(true)
       expect(mod.send(filetype.to_s + "?")).to be_truthy
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       module_file = File.join(path, dirname)
-      Puppet::FileSystem.expects(:exist?).with(module_file).returns false
+      expect(Puppet::FileSystem).to receive(:exist?).with(module_file).and_return(false)
       expect(mod.send(filetype.to_s + "?")).to be_falsey
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       module_file = File.join(path, dirname, "my/file")
-      Puppet::FileSystem.expects(:exist?).with(module_file).returns false
+      expect(Puppet::FileSystem).to receive(:exist?).with(module_file).and_return(false)
       expect(mod.send(filetype.to_s.sub(/s$/, ''), "my/file")).to be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       base = File.join(path, dirname)
-      Puppet::FileSystem.expects(:exist?).with(base).returns true
+      expect(Puppet::FileSystem).to receive(:exist?).with(base).and_return(true)
       expect(mod.send(filetype.to_s.sub(/s$/, ''), nil)).to eq(base)
     end
   end
@@ -532,9 +527,13 @@ describe Puppet::Module do
     expect(mod.tasks_directory).to eq(File.join(path, "tasks"))
   end
 
+  it "should return the path to the plans directory" do
+    expect(mod.plans_directory).to eq(File.join(path, "plans"))
+  end
+
   describe "when finding tasks" do
     before do
-      Puppet::FileSystem.unstub(:exist?)
+      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
@@ -568,6 +567,20 @@ describe Puppet::Module do
       expect(mod.task_file(task_exe)).to eq("#{mod.path}/tasks/#{task_exe}")
     end
 
+    it "should list files from the scripts directory if required by the task" do
+      mod         = 'loads_scripts'
+      task_dep    = 'myscript.sh'
+      script_ref  = "#{mod}/scripts/#{task_dep}"
+      task_json   = JSON.generate({'files' => [script_ref]})
+      task        = [['task', { name: 'task.json', content: task_json }]]
+      mod         = PuppetSpec::Modules.create(mod, @modpath, {:environment => env,
+                                                       :scripts     => [task_dep],
+                                                       :tasks       => task})
+
+      expect(mod.tasks.first.files).to include({'name' => script_ref,
+                                                'path' => /#{script_ref}/})
+    end
+
     it "should return nil when asked for an individual task file if it does not exist" do
       mod = PuppetSpec::Modules.create('task_file_neg', @modpath, {:environment => env,
                                                                    :tasks => []})
@@ -575,29 +588,24 @@ describe Puppet::Module do
     end
 
     describe "does the task finding" do
-      before :each do
-        Puppet::FileSystem.unstub(:exist?)
-        Puppet::Module::Task.unstub(:tasks_in_module)
-      end
-
       let(:mod_name) { 'tasks_test_lazy' }
       let(:mod_tasks_dir) { File.join(@modpath, mod_name, 'tasks') }
 
       it "after the module is initialized" do
-        Puppet::FileSystem.expects(:exist?).with(mod_tasks_dir).never
-        Puppet::Module::Task.expects(:tasks_in_module).never
+        expect(Puppet::FileSystem).not_to receive(:exist?).with(mod_tasks_dir)
+        expect(Puppet::Module::Task).not_to receive(:tasks_in_module)
         Puppet::Module.new(mod_name, @modpath, env)
       end
 
       it "when the tasks method is called" do
-        Puppet::Module::Task.expects(:tasks_in_module)
+        expect(Puppet::Module::Task).to receive(:tasks_in_module)
         mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
                                                               :tasks => [['itascanstaccatotask']]})
         mod.tasks
       end
 
       it "only once for the lifetime of the module object" do
-        Dir.expects(:glob).with("#{mod_tasks_dir}/*").once.returns ['allalaskataskattacktactics']
+        expect(Dir).to receive(:glob).with("#{mod_tasks_dir}/*").once.and_return(['allalaskataskattacktactics'])
         mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
                                                               :tasks => []})
         mod.tasks
@@ -605,50 +613,119 @@ describe Puppet::Module do
       end
     end
   end
+
+  describe "when finding plans" do
+    before do
+      allow(Puppet::FileSystem).to receive(:exist?).and_call_original
+      @modpath = tmpdir('modpath')
+      Puppet.settings[:modulepath] = @modpath
+    end
+
+    it "should have an empty array for the plans when the plans directory does not exist" do
+      mod = PuppetSpec::Modules.create('plans_test_nodir', @modpath, :environment => env)
+      expect(mod.plans).to eq([])
+    end
+
+    it "should have an empty array for the plans when the plans directory does exist and is empty" do
+      mod = PuppetSpec::Modules.create('plans_test_empty', @modpath, {:environment => env,
+                                                                      :plans => []})
+      expect(mod.plans).to eq([])
+    end
+
+    it "should list the expected plans when the required files exist" do
+      fake_plans = ['plan1.pp', 'plan2.yaml']
+      mod = PuppetSpec::Modules.create('plans_smoke', @modpath, {:environment => env,
+                                                                 :plans => fake_plans})
+
+      expect(mod.plans.count).to eq(2)
+      expect(mod.plans.map{|t| t.name}.sort).to eq(['plans_smoke::plan1', 'plans_smoke::plan2'])
+      expect(mod.plans.map{|t| t.class}).to eq([Puppet::Module::Plan] * 2)
+    end
+
+    it "should be able to find individual plan files when they exist" do
+      plan_exe = 'stateskateplan.pp'
+      mod = PuppetSpec::Modules.create('plan_file_smoke', @modpath, {:environment => env,
+                                                                     :plans => [plan_exe]})
+
+      expect(mod.plan_file(plan_exe)).to eq("#{mod.path}/plans/#{plan_exe}")
+    end
+
+    it "should return nil when asked for an individual plan file if it does not exist" do
+      mod = PuppetSpec::Modules.create('plan_file_neg', @modpath, {:environment => env,
+                                                                   :plans => []})
+      expect(mod.plan_file('nosuchplan')).to be_nil
+    end
+
+    describe "does the plan finding" do
+      let(:mod_name) { 'plans_test_lazy' }
+      let(:mod_plans_dir) { File.join(@modpath, mod_name, 'plans') }
+
+      it "after the module is initialized" do
+        expect(Puppet::FileSystem).not_to receive(:exist?).with(mod_plans_dir)
+        expect(Puppet::Module::Plan).not_to receive(:plans_in_module)
+        Puppet::Module.new(mod_name, @modpath, env)
+      end
+
+      it "when the plans method is called" do
+        expect(Puppet::Module::Plan).to receive(:plans_in_module)
+        mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
+                                                              :plans => ['itascanstaccatoplan.yaml']})
+        mod.plans
+      end
+
+      it "only once for the lifetime of the module object" do
+        expect(Dir).to receive(:glob).with("#{mod_plans_dir}/*").once.and_return(['allalaskaplanattacktactics'])
+        mod = PuppetSpec::Modules.create(mod_name, @modpath, {:environment => env,
+                                                              :plans => []})
+        mod.plans
+        mod.plans
+      end
+    end
+  end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
-    @mod = Puppet::Module.new("mymod", "/a", mock("environment"))
+    @mod = Puppet::Module.new("mymod", "/a", double("environment"))
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
 
   it "should return all manifests matching the glob pattern" do
-    Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
-    FileTest.stubs(:directory?).returns false
+    expect(Dir).to receive(:glob).with(@fq_glob_with_extension).and_return(%w{foo bar})
+    allow(FileTest).to receive(:directory?).and_return(false)
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%w{foo bar})
   end
 
   it "should not return directories" do
-    Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
+    expect(Dir).to receive(:glob).with(@fq_glob_with_extension).and_return(%w{foo bar})
 
-    FileTest.expects(:directory?).with("foo").returns false
-    FileTest.expects(:directory?).with("bar").returns true
+    expect(FileTest).to receive(:directory?).with("foo").and_return(false)
+    expect(FileTest).to receive(:directory?).with("bar").and_return(true)
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%w{foo})
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    Puppet::FileSystem.expects(:exist?).with("/a/manifests/init.pp").returns(true)
+    expect(Puppet::FileSystem).to receive(:exist?).with("/a/manifests/init.pp").and_return(true)
 
     expect(@mod.match_manifests(nil)).to eq(%w{/a/manifests/init.pp})
   end
 
   it "should return all manifests matching the glob pattern in all existing paths" do
-    Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{a b})
+    expect(Dir).to receive(:glob).with(@fq_glob_with_extension).and_return(%w{a b})
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%w{a b})
   end
 
   it "should match the glob pattern plus '.pp' if no extension is specified" do
-    Dir.expects(:glob).with("/a/manifests/yay/foo.pp").returns(%w{yay})
+    expect(Dir).to receive(:glob).with("/a/manifests/yay/foo.pp").and_return(%w{yay})
 
     expect(@mod.match_manifests("yay/foo")).to eq(%w{yay})
   end
 
   it "should return an empty array if no manifests matched" do
-    Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
+    expect(Dir).to receive(:glob).with(@fq_glob_with_extension).and_return([])
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq([])
   end
@@ -680,7 +757,7 @@ describe Puppet::Module do
   end
 
   it "should cache the license file" do
-    mymod.expects(:path).once.returns nil
+    expect(mymod).to receive(:path).once.and_return(nil)
     mymod.license_file
     mymod.license_file
   end
@@ -690,24 +767,24 @@ describe Puppet::Module do
   end
 
   it "should not have metadata if it has a metadata file and its data is valid but empty json hash" do
-    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns "{}"
+    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return("{}")
 
     expect(mymod).not_to be_has_metadata
   end
 
   it "should not have metadata if it has a metadata file and its data is empty" do
-    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns ""
+    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return("")
 
     expect(mymod).not_to be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is invalid" do
-    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
+    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return("This is some invalid json.\n")
     expect(mymod).not_to be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
-    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).raises(Errno::ENOENT)
+    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
 
     expect(mymod).not_to be_has_metadata
   end
@@ -717,13 +794,13 @@ describe Puppet::Module do
   end
 
   it "should parse its metadata file on initialization if it is present" do
-    Puppet::Module.any_instance.expects(:load_metadata)
+    expect_any_instance_of(Puppet::Module).to receive(:load_metadata)
 
-    Puppet::Module.new("yay", "/path", mock("env"))
+    Puppet::Module.new("yay", "/path", double("env"))
   end
 
   it "should tolerate failure to parse" do
-    File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+    allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
 
     expect(mymod.has_metadata?).to be_falsey
   end
@@ -734,7 +811,7 @@ describe Puppet::Module do
     end
 
     it "should warn about a failure to parse" do
-      File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+      allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
 
       expect(mymod.has_metadata?).to be_falsey
       expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file/)
@@ -747,7 +824,7 @@ describe Puppet::Module do
       end
 
       it "should not warn about a failure to parse" do
-        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+        allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
 
         expect(mymod.has_metadata?).to be_falsey
         expect(@logs).to_not have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
@@ -755,7 +832,7 @@ describe Puppet::Module do
 
       it "should log debug output about a failure to parse when --debug is on" do
         Puppet[:log_level] = :debug
-        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+        allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
 
         expect(mymod.has_metadata?).to be_falsey
         expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
@@ -768,7 +845,7 @@ describe Puppet::Module do
       end
 
       it "should fail on a failure to parse" do
-        File.stubs(:read).with(mymod_metadata, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+        allow(File).to receive(:read).with(mymod_metadata, {:encoding => 'utf-8'}).and_return(my_fixture('trailing-comma.json'))
 
         expect do
         expect(mymod.has_metadata?).to be_falsey
@@ -777,8 +854,8 @@ describe Puppet::Module do
     end
 
   def a_module_with_metadata(data)
-    File.stubs(:read).with("/path/metadata.json", {:encoding => 'utf-8'}).returns data.to_json
-    Puppet::Module.new("foo", "/path", mock("env"))
+    allow(File).to receive(:read).with("/path/metadata.json", {:encoding => 'utf-8'}).and_return(data.to_json)
+    Puppet::Module.new("foo", "/path", double("env"))
   end
 
   describe "when loading the metadata file" do
@@ -824,8 +901,8 @@ describe Puppet::Module do
         EOF
       end
 
-      Puppet::Module.any_instance.stubs(:metadata_file).returns metadata_json
-      mod = Puppet::Module.new('foo', '/path', mock('env'))
+      allow_any_instance_of(Puppet::Module).to receive(:metadata_file).and_return(metadata_json)
+      mod = Puppet::Module.new('foo', '/path', double('env'))
 
       mod.load_metadata
       expect(mod.author).to eq(rune_utf8)
@@ -906,62 +983,7 @@ describe Puppet::Module do
     let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
 
     it 'can parse a strict range' do
-      expect(Puppet::Module.parse_range('>=1.0.0', true).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_falsey
-    end
-
-    it 'can parse a non-strict range' do
-      expect(Puppet::Module.parse_range('>=1.0.0', false).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_truthy
-    end
-
-    context 'using parse method with an arity of 1' do
-      around(:each) do |example|
-        begin
-          example.run
-        ensure
-          Puppet::Module.instance_variable_set(:@semver_gem_version, nil)
-          Puppet::Module.instance_variable_set(:@parse_range_method, nil)
-        end
-      end
-
-      it 'will notify when non-strict ranges cannot be parsed' do
-        Puppet::Module.instance_variable_set(:@semver_gem_version, SemanticPuppet::Version.parse('1.0.0'))
-        Puppet::Module.instance_variable_set(:@parse_range_method, Proc.new { |str| SemanticPuppet::VersionRange.parse(str, true) })
-
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Puppet::Module.parse_range('>=1.0.0', false).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_falsey
-        end
-        expect(notices).to include(/VersionRanges will always be strict when using non-vendored SemanticPuppet gem, version 1\.0\.0/)
-      end
-
-      it 'will notify when strict ranges cannot be parsed' do
-        Puppet::Module.instance_variable_set(:@semver_gem_version, SemanticPuppet::Version.parse('0.1.4'))
-        Puppet::Module.instance_variable_set(:@parse_range_method, Proc.new { |str| SemanticPuppet::VersionRange.parse(str, false) })
-
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Puppet::Module.parse_range('>=1.0.0', true).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_truthy
-        end
-        expect(notices).to include(/VersionRanges will never be strict when using non-vendored SemanticPuppet gem, version 0\.1\.4/)
-      end
-
-      it 'will not notify when strict ranges can be parsed' do
-        Puppet::Module.instance_variable_set(:@semver_gem_version, SemanticPuppet::Version.parse('1.0.0'))
-        Puppet::Module.instance_variable_set(:@parse_range_method, Proc.new { |str| SemanticPuppet::VersionRange.parse(str, true) })
-
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Puppet::Module.parse_range('>=1.0.0', true).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_falsey
-        end
-        expect(notices).to be_empty
-      end
-
-      it 'will not notify when non-strict ranges can be parsed' do
-        Puppet::Module.instance_variable_set(:@semver_gem_version, SemanticPuppet::Version.parse('0.1.4'))
-        Puppet::Module.instance_variable_set(:@parse_range_method, Proc.new { |str| SemanticPuppet::VersionRange.parse(str, false) })
-
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Puppet::Module.parse_range('>=1.0.0', false).include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_truthy
-        end
-        expect(notices).to be_empty
-      end
+      expect(Puppet::Module.parse_range('>=1.0.0').include?(SemanticPuppet::Version.parse('1.0.1-rc1'))).to be_falsey
     end
   end
 end