puppet 5.5.12 → 5.5.13

data/spec/unit/indirector/yaml_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/yaml'
@@ -10,16 +9,14 @@ describe Puppet::Indirector::Yaml do
     attr_accessor :name
   end
 
-  before :all do
-    @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
-    Puppet::Indirector::Indirection.expects(:instance).with(:my_yaml).returns(@indirection)
+  before :each do
+    @indirection = Puppet::Indirector::Indirection.new(nil, :my_yaml)
+
     module MyYaml; end
     @store_class = class MyYaml::MyType < Puppet::Indirector::Yaml
       self
     end
-  end
 
-  before :each do
     @store = @store_class.new
 
     @subject = TestSubject.new
@@ -27,9 +24,13 @@ describe Puppet::Indirector::Yaml do
 
     @dir = tmpdir("yaml_indirector")
     Puppet[:clientyamldir] = @dir
-    Puppet.run_mode.stubs(:master?).returns false
+    allow(Puppet.run_mode).to receive(:master?).and_return(false)
+
+    @request = double('request', :key => :me, :instance => @subject)
+  end
 
-    @request = stub 'request', :key => :me, :instance => @subject
+  after(:each) do
+    @indirection.delete
   end
 
   let(:serverdir) { File.expand_path("/server/yaml/dir") }
@@ -37,25 +38,25 @@ describe Puppet::Indirector::Yaml do
 
   describe "when choosing file location" do
     it "should use the server_datadir if the run_mode is master" do
-      Puppet.run_mode.stubs(:master?).returns true
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(@store.path(:me)).to match(/^#{serverdir}/)
     end
 
     it "should use the client yamldir if the run_mode is not master" do
-      Puppet.run_mode.stubs(:master?).returns false
+      allow(Puppet.run_mode).to receive(:master?).and_return(false)
       Puppet[:clientyamldir] = clientdir
       expect(@store.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
-      Puppet.run_mode.stubs(:master?).returns true
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(@store.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
-      Puppet.run_mode.stubs(:master?).returns true
+      allow(Puppet.run_mode).to receive(:master?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(@store.path(:me)).to match(%r{\.yaml$})
     end
@@ -89,7 +90,7 @@ describe Puppet::Indirector::Yaml do
 
   describe "when storing objects as YAML" do
     it "should only store objects that respond to :name" do
-      @request.stubs(:instance).returns Object.new
+      allow(@request).to receive(:instance).and_return(Object.new)
       expect { @store.save(@request) }.to raise_error(ArgumentError)
     end
   end
@@ -117,29 +118,29 @@ describe Puppet::Indirector::Yaml do
 
   describe "when searching" do
     it "should return an array of fact instances with one instance for each file when globbing *" do
-      @request = stub 'request', :key => "*", :instance => @subject
-      @one = mock 'one'
-      @two = mock 'two'
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns(%w{one.yaml two.yaml})
-      YAML.expects(:load_file).with("one.yaml").returns @one;
-      YAML.expects(:load_file).with("two.yaml").returns @two;
+      @request = double('request', :key => "*", :instance => @subject)
+      @one = double('one')
+      @two = double('two')
+      expect(@store).to receive(:path).with(@request.key,'').and_return(:glob)
+      expect(Dir).to receive(:glob).with(:glob).and_return(%w{one.yaml two.yaml})
+      expect(YAML).to receive(:load_file).with("one.yaml").and_return(@one)
+      expect(YAML).to receive(:load_file).with("two.yaml").and_return(@two)
       expect(@store.search(@request)).to contain_exactly(@one, @two)
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do
-      @request = stub 'request', :key => "one*", :instance => @subject
-      @one = mock 'one'
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns(%w{one.yaml})
-      YAML.expects(:load_file).with("one.yaml").returns @one;
+      @request = double('request', :key => "one*", :instance => @subject)
+      @one = double('one')
+      expect(@store).to receive(:path).with(@request.key,'').and_return(:glob)
+      expect(Dir).to receive(:glob).with(:glob).and_return(%w{one.yaml})
+      expect(YAML).to receive(:load_file).with("one.yaml").and_return(@one)
       expect(@store.search(@request)).to eq([@one])
     end
 
     it "should return an empty array when the glob doesn't match anything" do
-      @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
-      @store.expects(:path).with(@request.key,'').returns :glob
-      Dir.expects(:glob).with(:glob).returns []
+      @request = double('request', :key => "f*ilglobcanfail*", :instance => @subject)
+      expect(@store).to receive(:path).with(@request.key,'').and_return(:glob)
+      expect(Dir).to receive(:glob).with(:glob).and_return([])
       expect(@store.search(@request)).to eq([])
     end
 
@@ -149,15 +150,15 @@ describe Puppet::Indirector::Yaml do
       end
 
       it "should unlink the right yaml file if it exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns true
-        Puppet::FileSystem.expects(:unlink).with(path)
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+        expect(Puppet::FileSystem).to receive(:unlink).with(path)
 
         @store.destroy(@request)
       end
 
       it "should not unlink the yaml file if it does not exists" do
-        Puppet::FileSystem.expects(:exist?).with(path).returns false
-        Puppet::FileSystem.expects(:unlink).with(path).never
+        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+        expect(Puppet::FileSystem).not_to receive(:unlink).with(path)
 
         @store.destroy(@request)
       end

data/spec/unit/indirector_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/defaults'
@@ -113,7 +112,7 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should pass any provided options to the indirection during initialization" do
-    Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
+    expect(Puppet::Indirector::Indirection).to receive(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
     @indirection = @thingie.indirects :first, :some => :options
   end
 

data/spec/unit/info_service_spec.rb

@@ -37,10 +37,12 @@ describe "Puppet::InfoService" do
           @result = Puppet::InfoService.task_data(env_name, mod_name, task_name)
         end
       end
+
       describe 'in the happy case' do
         it 'returns the right set of keys' do
           expect(@result.keys.sort).to eq([:files, :metadata_file])
         end
+
         it 'specifies the metadata_file correctly' do
           task = @mod.tasks[0]
           expect(@result[:metadata_file]).to eq(task.metadata_file)
@@ -248,7 +250,7 @@ describe "Puppet::InfoService" do
     it "avoids parsing file more than once when environments have same feature flag set" do
       # in this version of puppet, all environments are equal in this respect
       result = Puppet::Pops::Parser::EvaluatingParser.new.parse_file("#{code_dir}/fum.pp")
-      Puppet::Pops::Parser::EvaluatingParser.any_instance.expects(:parse_file).with("#{code_dir}/fum.pp").returns(result).once
+      expect_any_instance_of(Puppet::Pops::Parser::EvaluatingParser).to receive(:parse_file).with("#{code_dir}/fum.pp").once.and_return(result)
       files_production = ['fum.pp'].map {|f| File.join(code_dir, f) }
       files_test       = files_production
 

data/spec/unit/interface/action_builder_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
 require 'puppet/network/format_handler'

data/spec/unit/interface/action_manager_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/interface'

data/spec/unit/interface/action_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
 
@@ -138,7 +137,7 @@ describe Puppet::Interface::Action do
       end
 
       it "should call #validate_and_clean on the action when invoked" do
-        face.get_action(:bar).expects(:validate_and_clean).with({}).returns({})
+        expect(face.get_action(:bar)).to receive(:validate_and_clean).with({}).and_return({})
         face.bar 1, :two, 'three'
       end
     end
@@ -397,7 +396,7 @@ describe Puppet::Interface::Action do
 
       it "should not invoke a decorator if the options are empty" do
         face.option("--foo FOO") { before_action { |_,_,_| report :before_action } }
-        face.expects(:report).never
+        expect(face).not_to receive(:report)
         face.bar
       end
 

data/spec/unit/interface/documentation_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
 

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
 

data/spec/unit/man_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/face'
 
@@ -13,8 +12,8 @@ describe Puppet::Face[:man, :current] do
   end
 
   it "exits with 0 when generating man documentation for each available application" do
-    Puppet::Util.stubs(:which).with('ronn').returns(nil)
-    Puppet::Util.stubs(:which).with(pager).returns(pager)
+    allow(Puppet::Util).to receive(:which).with('ronn').and_return(nil)
+    allow(Puppet::Util).to receive(:which).with(pager).and_return(pager)
 
     Puppet::Application.available_application_names.each do |name|
       next if %w{man face_base indirection_base}.include? name
@@ -23,7 +22,7 @@ describe Puppet::Face[:man, :current] do
       app = klass.new(Puppet::Util::CommandLine.new('puppet', ['man', name]))
 
       expect do
-        IO.stubs(:popen).with(pager, 'w:UTF-8').yields($stdout)
+        allow(IO).to receive(:popen).with(pager, 'w:UTF-8').and_yield($stdout)
 
         expect { app.run }.to exit_with(0)
       end.to_not have_printed(/undefined method `gsub'/)

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,7 +162,7 @@ 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
@@ -181,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,
@@ -205,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,
@@ -222,7 +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"
-        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',
@@ -488,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
@@ -529,7 +529,7 @@ describe Puppet::Module do
 
   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
@@ -570,29 +570,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
@@ -604,46 +599,46 @@ 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
@@ -675,7 +670,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
@@ -685,24 +680,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
@@ -712,13 +707,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
@@ -729,7 +724,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/)
@@ -742,7 +737,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.*/)
@@ -750,7 +745,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.*/)
@@ -763,7 +758,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
@@ -772,8 +767,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
@@ -819,8 +814,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)