puppet 6.0.10 → 6.1.0

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

@@ -1,10 +1,11 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/file'
 
 module FileServingMountTesting
   def stub_facter(hostname)
-    allow(Facter).to receive(:value).with("hostname").and_return(hostname.sub(/\..+/, ''))
-    allow(Facter).to receive(:value).with("domain").and_return(hostname.sub(/^[^.]+\./, ''))
+    Facter.stubs(:value).with("hostname").returns(hostname.sub(/\..+/, ''))
+    Facter.stubs(:value).with("domain").returns(hostname.sub(/^[^.]+\./, ''))
   end
 end
 
@@ -14,8 +15,8 @@ describe Puppet::FileServing::Mount::File do
   end
 
   it "should be valid if it has a path" do
-    allow(FileTest).to receive(:directory?).and_return(true)
-    allow(FileTest).to receive(:readable?).and_return(true)
+    FileTest.stubs(:directory?).returns true
+    FileTest.stubs(:readable?).returns true
     mount = Puppet::FileServing::Mount::File.new("foo")
     mount.path = "/foo"
     expect { mount.validate }.not_to raise_error
@@ -28,13 +29,13 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should fail if the path is not a directory" do
-      expect(FileTest).to receive(:directory?).and_return(false)
+      FileTest.expects(:directory?).returns(false)
       expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
 
     it "should fail if the path is not readable" do
-      expect(FileTest).to receive(:directory?).and_return(true)
-      expect(FileTest).to receive(:readable?).and_return(false)
+      FileTest.expects(:directory?).returns(true)
+      FileTest.expects(:readable?).returns(false)
       expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
   end
@@ -43,8 +44,8 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @host = "host.domain.com"
     end
@@ -84,9 +85,9 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
@@ -94,25 +95,25 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return nil if the file is absent" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       expect(@mount.complete_path("/my/path", nil)).to be_nil
     end
 
     it "should write a log message if the file is absent" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
 
-      expect(Puppet).to receive(:info).with("File does not exist or is not accessible: /mount/my/path")
+      Puppet.expects(:info).with("File does not exist or is not accessible: /mount/my/path")
 
       @mount.complete_path("/my/path", nil)
     end
 
     it "should return the file path if the file is present" do
-      allow(Puppet::FileSystem).to receive(:exist?).with("/my/path").and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with("/my/path").returns(true)
       expect(@mount.complete_path("/my/path", nil)).to eq("/mount/my/path")
     end
 
     it "should treat a nil file name as the path to the mount itself" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       expect(@mount.complete_path(nil, nil)).to eq("/mount")
     end
 
@@ -140,20 +141,20 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
       @host = "host.domain.com"
 
-      @request = double('request', :node => "foo")
+      @request = stub 'request', :node => "foo"
     end
 
     it "should return the results of the complete file path" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return("eh")
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       expect(@mount.find("/my/path", @request)).to eq("eh")
     end
   end
@@ -162,26 +163,26 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
       @host = "host.domain.com"
 
-      @request = double('request', :node => "foo")
+      @request = stub 'request', :node => "foo"
     end
 
     it "should return the results of the complete file path as an array" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return("eh")
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       expect(@mount.search("/my/path", @request)).to eq(["eh"])
     end
 
     it "should return nil if the complete path is nil" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return(nil)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns nil
       expect(@mount.search("/my/path", @request)).to be_nil
     end
   end

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

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

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

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

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

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