puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

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

@@ -1,188 +0,0 @@
-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(/^[^.]+\./, ''))
-  end
-end
-
-describe Puppet::FileServing::Mount::File do
-  it "should be invalid if it does not have a path" do
-    expect { Puppet::FileServing::Mount::File.new("foo").validate }.to raise_error(ArgumentError)
-  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)
-    mount = Puppet::FileServing::Mount::File.new("foo")
-    mount.path = "/foo"
-    expect { mount.validate }.not_to raise_error
-  end
-
-  describe "when setting the path" do
-    before do
-      @mount = Puppet::FileServing::Mount::File.new("test")
-      @dir = "/this/path/does/not/exist"
-    end
-
-    it "should fail if the path is not a directory" do
-      expect(FileTest).to receive(:directory?).and_return(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)
-      expect { @mount.path = @dir }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "when substituting hostnames and ip addresses into file paths" do
-    include FileServingMountTesting
-
-    before do
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
-      @mount = Puppet::FileServing::Mount::File.new("test")
-      @host = "host.domain.com"
-    end
-
-    after :each do
-      Puppet::FileServing::Mount::File.instance_variable_set(:@localmap, nil)
-    end
-
-    it "should replace incidences of %h in the path with the client's short name" do
-      @mount.path = "/dir/%h/yay"
-      expect(@mount.path(@host)).to eq("/dir/host/yay")
-    end
-
-    it "should replace incidences of %H in the path with the client's fully qualified name" do
-      @mount.path = "/dir/%H/yay"
-      expect(@mount.path(@host)).to eq("/dir/host.domain.com/yay")
-    end
-
-    it "should replace incidences of %d in the path with the client's domain name" do
-      @mount.path = "/dir/%d/yay"
-      expect(@mount.path(@host)).to eq("/dir/domain.com/yay")
-    end
-
-    it "should perform all necessary replacements" do
-      @mount.path = "/%h/%d/%H"
-      expect(@mount.path(@host)).to eq("/host/domain.com/host.domain.com")
-    end
-
-    it "should use local host information if no client data is provided" do
-      stub_facter("myhost.mydomain.com")
-      @mount.path = "/%h/%d/%H"
-      expect(@mount.path).to eq("/myhost/mydomain.com/myhost.mydomain.com")
-    end
-  end
-
-  describe "when determining the complete file path" 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)
-      @mount = Puppet::FileServing::Mount::File.new("test")
-      @mount.path = "/mount"
-      stub_facter("myhost.mydomain.com")
-      @host = "host.domain.com"
-    end
-
-    it "should return nil if the file is absent" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(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)
-
-      expect(Puppet).to receive(: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)
-      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)
-      expect(@mount.complete_path(nil, nil)).to eq("/mount")
-    end
-
-    it "should use the client host name if provided in the options" do
-      @mount.path = "/mount/%h"
-      expect(@mount.complete_path("/my/path", @host)).to eq("/mount/host/my/path")
-    end
-
-    it "should perform replacements on the base path" do
-      @mount.path = "/blah/%h"
-      expect(@mount.complete_path("/my/stuff", @host)).to eq("/blah/host/my/stuff")
-    end
-
-    it "should not perform replacements on the per-file path" do
-      @mount.path = "/blah"
-      expect(@mount.complete_path("/%h/stuff", @host)).to eq("/blah/%h/stuff")
-    end
-
-    it "should look for files relative to its base directory" do
-      expect(@mount.complete_path("/my/stuff", @host)).to eq("/mount/my/stuff")
-    end
-  end
-
-  describe "when finding files" 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)
-      @mount = Puppet::FileServing::Mount::File.new("test")
-      @mount.path = "/mount"
-      stub_facter("myhost.mydomain.com")
-      @host = "host.domain.com"
-
-      @request = double('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")
-      expect(@mount.find("/my/path", @request)).to eq("eh")
-    end
-  end
-
-  describe "when searching for files" 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)
-      @mount = Puppet::FileServing::Mount::File.new("test")
-      @mount.path = "/mount"
-      stub_facter("myhost.mydomain.com")
-      @host = "host.domain.com"
-
-      @request = double('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")
-      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)
-      expect(@mount.search("/my/path", @request)).to be_nil
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/locales'
-
-describe Puppet::FileServing::Mount::Locales do
-  before do
-    @mount = Puppet::FileServing::Mount::Locales.new("locales")
-
-    @environment = double('environment', :module => nil)
-    @options = { :recurse => true }
-    @request = double('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([])
-
-      @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)
-
-      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 = double('module')
-      allow(mod).to receive(:locale).with("foo/bar").and_return("eh")
-
-      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
-      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 locales" do
-      mod = double('module')
-      allow(mod).to receive(:locales?).and_return(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 the default search module path 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)
-
-      allow(@environment).to receive(:modules).and_return([])
-      allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
-    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")
-
-      allow(@environment).to receive(:modules).and_return([one, two])
-      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/modules'
-
-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)
-  end
-
-  describe "when finding files" do
-    it "should fail if no module is specified" do
-      expect { @mount.find("", @request) }.to raise_error(/No module specified/)
-    end
-
-    it "should use the provided environment to find the module" do
-      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
-      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
-      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 = 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
-
-  describe "when searching for files" do
-    it "should fail if no module is specified" do
-      expect { @mount.search("", @request) }.to raise_error(/No module specified/)
-    end
-
-    it "should use the node's environment to search the module" do
-      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
-      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
-      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 = 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
-end

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/pluginfacts'
-
-describe Puppet::FileServing::Mount::PluginFacts do
-  before do
-    @mount = Puppet::FileServing::Mount::PluginFacts.new("pluginfacts")
-
-    @environment = double('environment', :module => nil)
-    @options = { :recurse => true }
-    @request = double('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([])
-
-      @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)
-
-      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 = double('module')
-      allow(mod).to receive(:pluginfact).with("foo/bar").and_return("eh")
-
-      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
-      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 = double('module')
-      allow(mod).to receive(:pluginfacts?).and_return(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 the default search module path 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)
-
-      allow(@environment).to receive(:modules).and_return([])
-      allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
-    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")
-
-      allow(@environment).to receive(:modules).and_return([one, two])
-      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/plugins'
-
-describe Puppet::FileServing::Mount::Plugins do
-  before do
-    @mount = Puppet::FileServing::Mount::Plugins.new("plugins")
-
-    @environment = double('environment', :module => nil)
-    @options = { :recurse => true }
-    @request = double('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([])
-
-      @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)
-
-      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 = double('module')
-      allow(mod).to receive(:plugin).with("foo/bar").and_return("eh")
-
-      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
-      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 = double('module')
-      allow(mod).to receive(:plugins?).and_return(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 the default search module path 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)
-
-      allow(@environment).to receive(:modules).and_return([])
-      allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
-    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")
-
-      allow(@environment).to receive(:modules).and_return([one, two])
-      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/scripts'
-
-describe Puppet::FileServing::Mount::Scripts do
-  before do
-    @mount = Puppet::FileServing::Mount::Scripts.new("scripts")
-
-    @environment = double('environment', :module => nil)
-    @request = double('request', :environment => @environment)
-  end
-
-  describe "when finding files" do
-    it "should fail if no module is specified" do
-      expect { @mount.find("", @request) }.to raise_error(/No module specified/)
-    end
-
-    it "should use the provided environment to find the module" do
-      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
-      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
-      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 = double('module')
-      expect(mod).to receive(:script).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
-
-  describe "when searching for files" do
-    it "should fail if no module is specified" do
-      expect { @mount.search("", @request) }.to raise_error(/No module specified/)
-    end
-
-    it "should use the node's environment to search the module" do
-      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
-      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
-      expect(@environment).to receive(:module).with("foo").and_return(nil)
-      @mount.search("foo/bar/baz", @request)
-    end
-
-    it "should return the script path as an array from the module" do
-      mod = double('module')
-      expect(mod).to receive(:script).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
-end

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount/tasks'
-
-describe Puppet::FileServing::Mount::Tasks do
-  before do
-    @mount = Puppet::FileServing::Mount::Tasks.new("tasks")
-
-    @environment = double('environment', :module => nil)
-    @request = double('request', :environment => @environment)
-  end
-
-  describe "when finding task files" do
-    it "should fail if no task is specified" do
-      expect { @mount.find("", @request) }.to raise_error(/No task specified/)
-    end
-
-    it "should use the request's environment to find the module" do
-      mod_name = 'foo'
-      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
-      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
-      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 = 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
-
-  describe "when searching for task files" do
-    it "should fail if no module is specified" do
-      expect { @mount.search("", @request) }.to raise_error(/No task specified/)
-    end
-
-    it "should use the request's environment to find the module" do
-      mod_name = 'foo'
-      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
-      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
-      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 = 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
-end

data/spec/unit/file_serving/mount_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/mount'
-
-describe Puppet::FileServing::Mount do
-  it "should use 'mount[$name]' as its string form" do
-    expect(Puppet::FileServing::Mount.new("foo").to_s).to eq("mount[foo]")
-  end
-end
-
-describe Puppet::FileServing::Mount, " when initializing" do
-  it "should fail on non-alphanumeric name" do
-    expect { Puppet::FileServing::Mount.new("non alpha") }.to raise_error(ArgumentError)
-  end
-
-  it "should allow dashes in its name" do
-    expect(Puppet::FileServing::Mount.new("non-alpha").name).to eq("non-alpha")
-  end
-end
-
-describe Puppet::FileServing::Mount, " when finding files" do
-  it "should fail" do
-    expect { Puppet::FileServing::Mount.new("test").find("foo", :one => "two") }.to raise_error(NotImplementedError)
-  end
-end
-
-describe Puppet::FileServing::Mount, " when searching for files" do
-  it "should fail" do
-    expect { Puppet::FileServing::Mount.new("test").search("foo", :one => "two") }.to raise_error(NotImplementedError)
-  end
-end