puppet 5.5.12 → 5.5.13

data/spec/unit/file_serving/mount/modules_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/modules'
 
@@ -6,8 +5,8 @@ describe Puppet::FileServing::Mount::Modules do
   before do
     @mount = Puppet::FileServing::Mount::Modules.new("modules")
 
-    @environment = stub 'environment', :module => nil
-    @request = stub 'request', :environment => @environment
+    @environment = double('environment', :module => nil)
+    @request = double('request', :environment => @environment)
   end
 
   describe "when finding files" do
@@ -16,25 +15,25 @@ describe Puppet::FileServing::Mount::Modules do
     end
 
     it "should use the provided environment to find the module" do
-      @environment.expects(:module)
+      expect(@environment).to receive(:module)
 
       @mount.find("foo", @request)
     end
 
     it "should treat the first field of the relative path as the module name" do
-      @environment.expects(:module).with("foo")
+      expect(@environment).to receive(:module).with("foo")
       @mount.find("foo/bar/baz", @request)
     end
 
     it "should return nil if the specified module does not exist" do
-      @environment.expects(:module).with("foo").returns nil
+      expect(@environment).to receive(:module).with("foo")
       @mount.find("foo/bar/baz", @request)
     end
 
     it "should return the file path from the module" do
-      mod = mock 'module'
-      mod.expects(:file).with("bar/baz").returns "eh"
-      @environment.expects(:module).with("foo").returns mod
+      mod = double('module')
+      expect(mod).to receive(:file).with("bar/baz").and_return("eh")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
       expect(@mount.find("foo/bar/baz", @request)).to eq("eh")
     end
   end
@@ -45,25 +44,25 @@ describe Puppet::FileServing::Mount::Modules do
     end
 
     it "should use the node's environment to search the module" do
-      @environment.expects(:module)
+      expect(@environment).to receive(:module)
 
       @mount.search("foo", @request)
     end
 
     it "should treat the first field of the relative path as the module name" do
-      @environment.expects(:module).with("foo")
+      expect(@environment).to receive(:module).with("foo")
       @mount.search("foo/bar/baz", @request)
     end
 
     it "should return nil if the specified module does not exist" do
-      @environment.expects(:module).with("foo").returns nil
+      expect(@environment).to receive(:module).with("foo").and_return(nil)
       @mount.search("foo/bar/baz", @request)
     end
 
     it "should return the file path as an array from the module" do
-      mod = mock 'module'
-      mod.expects(:file).with("bar/baz").returns "eh"
-      @environment.expects(:module).with("foo").returns mod
+      mod = double('module')
+      expect(mod).to receive(:file).with("bar/baz").and_return("eh")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
       expect(@mount.search("foo/bar/baz", @request)).to eq(["eh"])
     end
   end

data/spec/unit/file_serving/mount/pluginfacts_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/pluginfacts'
 
@@ -6,67 +5,67 @@ describe Puppet::FileServing::Mount::PluginFacts do
   before do
     @mount = Puppet::FileServing::Mount::PluginFacts.new("pluginfacts")
 
-    @environment = stub 'environment', :module => nil
+    @environment = double('environment', :module => nil)
     @options = { :recurse => true }
-    @request = stub 'request', :environment => @environment, :options => @options
+    @request = double('request', :environment => @environment, :options => @options)
   end
 
   describe  "when finding files" do
     it "should use the provided environment to find the modules" do
-      @environment.expects(:modules).returns []
+      expect(@environment).to receive(:modules).and_return([])
 
       @mount.find("foo", @request)
     end
 
     it "should return nil if no module can be found with a matching plugin" do
-      mod = mock 'module'
-      mod.stubs(:pluginfact).with("foo/bar").returns nil
+      mod = double('module')
+      allow(mod).to receive(:pluginfact).with("foo/bar").and_return(nil)
 
-      @environment.stubs(:modules).returns [mod]
+      allow(@environment).to receive(:modules).and_return([mod])
       expect(@mount.find("foo/bar", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = mock 'module'
-      mod.stubs(:pluginfact).with("foo/bar").returns "eh"
+      mod = double('module')
+      allow(mod).to receive(:pluginfact).with("foo/bar").and_return("eh")
 
-      @environment.stubs(:modules).returns [mod]
+      allow(@environment).to receive(:modules).and_return([mod])
       expect(@mount.find("foo/bar", @request)).to eq("eh")
     end
   end
 
   describe "when searching for files" do
     it "should use the node's environment to find the modules" do
-      @environment.expects(:modules).at_least_once.returns []
-      @environment.stubs(:modulepath).returns ["/tmp/modules"]
+      expect(@environment).to receive(:modules).at_least(:once).and_return([])
+      allow(@environment).to receive(:modulepath).and_return(["/tmp/modules"])
 
       @mount.search("foo", @request)
     end
 
     it "should return modulepath if no modules can be found that have plugins" do
-      mod = mock 'module'
-      mod.stubs(:pluginfacts?).returns false
+      mod = double('module')
+      allow(mod).to receive(:pluginfacts?).and_return(false)
 
-      @environment.stubs(:modules).returns []
-      @environment.stubs(:modulepath).returns ["/"]
-      @options.expects(:[]=).with(:recurse, false)
+      allow(@environment).to receive(:modules).and_return([])
+      allow(@environment).to receive(:modulepath).and_return(["/"])
+      expect(@options).to receive(:[]=).with(:recurse, false)
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
     it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
-      mod = mock 'module'
-      mod.stubs(:pluginfacts?).returns false
+      mod = double('module')
+      allow(mod).to receive(:pluginfacts?).and_return(false)
 
-      @environment.stubs(:modules).returns []
-      @environment.stubs(:modulepath).returns []
+      allow(@environment).to receive(:modules).and_return([])
+      allow(@environment).to receive(:modulepath).and_return([])
       expect(@mount.search("foo/bar", @request)).to be_nil
     end
 
     it "should return the plugin paths for each module that has plugins" do
-      one = stub 'module', :pluginfacts? => true, :plugin_fact_directory => "/one"
-      two = stub 'module', :pluginfacts? => true, :plugin_fact_directory => "/two"
+      one = double('module', :pluginfacts? => true, :plugin_fact_directory => "/one")
+      two = double('module', :pluginfacts? => true, :plugin_fact_directory => "/two")
 
-      @environment.stubs(:modules).returns [one, two]
+      allow(@environment).to receive(:modules).and_return([one, two])
       expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
     end
   end

data/spec/unit/file_serving/mount/plugins_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/plugins'
 
@@ -6,67 +5,67 @@ describe Puppet::FileServing::Mount::Plugins do
   before do
     @mount = Puppet::FileServing::Mount::Plugins.new("plugins")
 
-    @environment = stub 'environment', :module => nil
+    @environment = double('environment', :module => nil)
     @options = { :recurse => true }
-    @request = stub 'request', :environment => @environment, :options => @options
+    @request = double('request', :environment => @environment, :options => @options)
   end
 
   describe  "when finding files" do
     it "should use the provided environment to find the modules" do
-      @environment.expects(:modules).returns []
+      expect(@environment).to receive(:modules).and_return([])
 
       @mount.find("foo", @request)
     end
 
     it "should return nil if no module can be found with a matching plugin" do
-      mod = mock 'module'
-      mod.stubs(:plugin).with("foo/bar").returns nil
+      mod = double('module')
+      allow(mod).to receive(:plugin).with("foo/bar").and_return(nil)
 
-      @environment.stubs(:modules).returns [mod]
+      allow(@environment).to receive(:modules).and_return([mod])
       expect(@mount.find("foo/bar", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = mock 'module'
-      mod.stubs(:plugin).with("foo/bar").returns "eh"
+      mod = double('module')
+      allow(mod).to receive(:plugin).with("foo/bar").and_return("eh")
 
-      @environment.stubs(:modules).returns [mod]
+      allow(@environment).to receive(:modules).and_return([mod])
       expect(@mount.find("foo/bar", @request)).to eq("eh")
     end
   end
 
   describe "when searching for files" do
     it "should use the node's environment to find the modules" do
-      @environment.expects(:modules).at_least_once.returns []
-      @environment.stubs(:modulepath).returns ["/tmp/modules"]
+      expect(@environment).to receive(:modules).at_least(:once).and_return([])
+      allow(@environment).to receive(:modulepath).and_return(["/tmp/modules"])
 
       @mount.search("foo", @request)
     end
 
     it "should return modulepath if no modules can be found that have plugins" do
-      mod = mock 'module'
-      mod.stubs(:plugins?).returns false
+      mod = double('module')
+      allow(mod).to receive(:plugins?).and_return(false)
 
-      @environment.stubs(:modules).returns []
-      @environment.stubs(:modulepath).returns ["/"]
-      @options.expects(:[]=).with(:recurse, false)
+      allow(@environment).to receive(:modules).and_return([])
+      allow(@environment).to receive(:modulepath).and_return(["/"])
+      expect(@options).to receive(:[]=).with(:recurse, false)
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
     it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
-      mod = mock 'module'
-      mod.stubs(:plugins?).returns false
+      mod = double('module')
+      allow(mod).to receive(:plugins?).and_return(false)
 
-      @environment.stubs(:modules).returns []
-      @environment.stubs(:modulepath).returns []
+      allow(@environment).to receive(:modules).and_return([])
+      allow(@environment).to receive(:modulepath).and_return([])
       expect(@mount.search("foo/bar", @request)).to be_nil
     end
 
     it "should return the plugin paths for each module that has plugins" do
-      one = stub 'module', :plugins? => true, :plugin_directory => "/one"
-      two = stub 'module', :plugins? => true, :plugin_directory => "/two"
+      one = double('module', :plugins? => true, :plugin_directory => "/one")
+      two = double('module', :plugins? => true, :plugin_directory => "/two")
 
-      @environment.stubs(:modules).returns [one, two]
+      allow(@environment).to receive(:modules).and_return([one, two])
       expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
     end
   end

data/spec/unit/file_serving/mount/tasks_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/tasks'
 
@@ -6,8 +5,8 @@ describe Puppet::FileServing::Mount::Tasks do
   before do
     @mount = Puppet::FileServing::Mount::Tasks.new("tasks")
 
-    @environment = stub 'environment', :module => nil
-    @request = stub 'request', :environment => @environment
+    @environment = double('environment', :module => nil)
+    @request = double('request', :environment => @environment)
   end
 
   describe "when finding task files" do
@@ -17,25 +16,25 @@ describe Puppet::FileServing::Mount::Tasks do
 
     it "should use the request's environment to find the module" do
       mod_name = 'foo'
-      @environment.expects(:module).with(mod_name)
+      expect(@environment).to receive(:module).with(mod_name)
 
       @mount.find(mod_name, @request)
     end
 
     it "should use the first segment of the request's path as the module name" do
-      @environment.expects(:module).with("foo")
+      expect(@environment).to receive(:module).with("foo")
       @mount.find("foo/bartask", @request)
     end
 
     it "should return nil if the module in the path doesn't exist" do
-      @environment.expects(:module).with("foo").returns(nil)
+      expect(@environment).to receive(:module).with("foo").and_return(nil)
       expect(@mount.find("foo/bartask", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = mock('module')
-      mod.expects(:task_file).with("bartask").returns("mocked")
-      @environment.expects(:module).with("foo").returns(mod)
+      mod = double('module')
+      expect(mod).to receive(:task_file).with("bartask").and_return("mocked")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
       expect(@mount.find("foo/bartask", @request)).to eq("mocked")
     end
   end
@@ -47,25 +46,25 @@ describe Puppet::FileServing::Mount::Tasks do
 
     it "should use the request's environment to find the module" do
       mod_name = 'foo'
-      @environment.expects(:module).with(mod_name)
+      expect(@environment).to receive(:module).with(mod_name)
 
       @mount.search(mod_name, @request)
     end
 
     it "should use the first segment of the request's path as the module name" do
-      @environment.expects(:module).with("foo")
+      expect(@environment).to receive(:module).with("foo")
       @mount.search("foo/bartask", @request)
     end
 
     it "should return nil if the module in the path doesn't exist" do
-      @environment.expects(:module).with("foo").returns(nil)
+      expect(@environment).to receive(:module).with("foo").and_return(nil)
       expect(@mount.search("foo/bartask", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = mock('module')
-      mod.expects(:task_file).with("bartask").returns("mocked")
-      @environment.expects(:module).with("foo").returns(mod)
+      mod = double('module')
+      expect(mod).to receive(:task_file).with("bartask").and_return("mocked")
+      expect(@environment).to receive(:module).with("foo").and_return(mod)
       expect(@mount.search("foo/bartask", @request)).to eq(["mocked"])
     end
   end

data/spec/unit/file_serving/mount_spec.rb

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

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/terminus_helper'
@@ -8,103 +7,99 @@ describe Puppet::FileServing::TerminusHelper do
     @helper = Object.new
     @helper.extend(Puppet::FileServing::TerminusHelper)
 
-    @model = mock 'model'
-    @helper.stubs(:model).returns(@model)
+    @model = double('model')
+    allow(@helper).to receive(:model).and_return(@model)
 
-    @request = stub 'request', :key => "url", :options => {}
+    @request = double('request', :key => "url", :options => {})
 
-    @fileset = stub 'fileset', :files => [], :path => "/my/file"
-    Puppet::FileServing::Fileset.stubs(:new).with("/my/file", {}).returns(@fileset)
+    @fileset = double('fileset', :files => [], :path => "/my/file")
+    allow(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", {}).and_return(@fileset)
   end
 
   it "should find a file with absolute path" do
-    file = stub 'file', :collect => nil
-    file.expects(:collect).with(nil)
-    @model.expects(:new).with("/my/file", {:relative_path => nil}).returns(file)
+    file = double('file', :collect => nil)
+    expect(file).to receive(:collect).with(no_args)
+    expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(file)
     @helper.path2instance(@request, "/my/file")
   end
 
   it "should pass through links, checksum_type, and source_permissions" do
-    file = stub 'file', :checksum_type= => nil, :links= => nil, :collect => nil
+    file = double('file', :checksum_type= => nil, :links= => nil, :collect => nil)
     [[:checksum_type, :sha256], [:links, true], [:source_permissions, :use]].each {|k, v|
-      file.expects(k.to_s+'=').with(v)
+      expect(file).to receive(k.to_s+'=').with(v)
       @request.options[k] = v
     }
-    file.expects(:collect)
-    @model.expects(:new).with("/my/file", {:relative_path => :file}).returns(file)
+    expect(file).to receive(:collect)
+    expect(@model).to receive(:new).with("/my/file", {:relative_path => :file}).and_return(file)
     @helper.path2instance(@request, "/my/file", {:relative_path => :file})
   end
 
   it "should use a fileset to find paths" do
-    @fileset = stub 'fileset', :files => [], :path => "/my/files"
-    Puppet::FileServing::Fileset.expects(:new).with { |key, options| key == "/my/file" }.returns(@fileset)
+    @fileset = double('fileset', :files => [], :path => "/my/files")
+    expect(Puppet::FileServing::Fileset).to receive(:new).with("/my/file", anything).and_return(@fileset)
     @helper.path2instances(@request, "/my/file")
   end
 
   it "should support finding across multiple paths by merging the filesets" do
-    first = stub 'fileset', :files => [], :path => "/first/file"
-    Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/first/file" }.returns(first)
-    second = stub 'fileset', :files => [], :path => "/second/file"
-    Puppet::FileServing::Fileset.expects(:new).with { |path, options| path == "/second/file" }.returns(second)
+    first = double('fileset', :files => [], :path => "/first/file")
+    expect(Puppet::FileServing::Fileset).to receive(:new).with("/first/file", anything).and_return(first)
+    second = double('fileset', :files => [], :path => "/second/file")
+    expect(Puppet::FileServing::Fileset).to receive(:new).with("/second/file", anything).and_return(second)
 
-    Puppet::FileServing::Fileset.expects(:merge).with(first, second).returns({})
+    expect(Puppet::FileServing::Fileset).to receive(:merge).with(first, second).and_return({})
 
     @helper.path2instances(@request, "/first/file", "/second/file")
   end
 
   it "should pass the indirection request to the Fileset at initialization" do
-    Puppet::FileServing::Fileset.expects(:new).with { |path, options| options == @request }.returns @fileset
+    expect(Puppet::FileServing::Fileset).to receive(:new).with(anything, @request).and_return(@fileset)
     @helper.path2instances(@request, "/my/file")
   end
 
   describe "when creating instances" do
     before do
-      @request.stubs(:key).returns "puppet://host/mount/dir"
+      allow(@request).to receive(:key).and_return("puppet://host/mount/dir")
 
-      @one = stub 'one', :links= => nil, :collect => nil
-      @two = stub 'two', :links= => nil, :collect => nil
+      @one = double('one', :links= => nil, :collect => nil)
+      @two = double('two', :links= => nil, :collect => nil)
 
-      @fileset = stub 'fileset', :files => %w{one two}, :path => "/my/file"
-      Puppet::FileServing::Fileset.stubs(:new).returns(@fileset)
+      @fileset = double('fileset', :files => %w{one two}, :path => "/my/file")
+      allow(Puppet::FileServing::Fileset).to receive(:new).and_return(@fileset)
     end
 
     it "should set each returned instance's path to the original path" do
-      @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@one)
-      @model.expects(:new).with { |key, options| key == "/my/file" }.returns(@two)
+      expect(@model).to receive(:new).with("/my/file", anything).and_return(@one, @two)
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set each returned instance's relative path to the file-specific path" do
-      @model.expects(:new).with { |key, options| options[:relative_path] == "one" }.returns(@one)
-      @model.expects(:new).with { |key, options| options[:relative_path] == "two" }.returns(@two)
+      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "one")).and_return(@one)
+      expect(@model).to receive(:new).with(anything, hash_including(relative_path: "two")).and_return(@two)
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set the links value on each instance if one is provided" do
-      @one.expects(:links=).with :manage
-      @two.expects(:links=).with :manage
-      @model.expects(:new).returns(@one)
-      @model.expects(:new).returns(@two)
+      expect(@one).to receive(:links=).with(:manage)
+      expect(@two).to receive(:links=).with(:manage)
+      expect(@model).to receive(:new).and_return(@one, @two)
 
       @request.options[:links] = :manage
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should set the request checksum_type if one is provided" do
-      @one.expects(:checksum_type=).with :test
-      @two.expects(:checksum_type=).with :test
-      @model.expects(:new).returns(@one)
-      @model.expects(:new).returns(@two)
+      expect(@one).to receive(:checksum_type=).with(:test)
+      expect(@two).to receive(:checksum_type=).with(:test)
+      expect(@model).to receive(:new).and_return(@one, @two)
 
       @request.options[:checksum_type] = :test
       @helper.path2instances(@request, "/my/file")
     end
 
     it "should collect the instance's attributes" do
-      @one.expects(:collect)
-      @two.expects(:collect)
-      @model.expects(:new).returns(@one)
-      @model.expects(:new).returns(@two)
+      expect(@one).to receive(:collect)
+      expect(@two).to receive(:collect)
+      expect(@model).to receive(:new).and_return(@one, @two)
 
       @helper.path2instances(@request, "/my/file")
     end