RubyGems - puppet - Versions diffs - 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32 - Mend

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

Files changed (1257) hide show

data/spec/unit/file_serving/configuration/parser_spec.rb DELETED Viewed

@@ -1,206 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/configuration/parser'
-module FSConfigurationParserTesting
-  def write_config_file(content)
-    # We want an array, but we actually want our carriage returns on all of it.
-    File.open(@path, 'w') {|f| f.puts content}
-  end
-end
-describe Puppet::FileServing::Configuration::Parser do
-  include PuppetSpec::Files
-  before :each do
-    @path = tmpfile('fileserving_config')
-    FileUtils.touch(@path)
-    @parser = Puppet::FileServing::Configuration::Parser.new(@path)
-  end
-  describe Puppet::FileServing::Configuration::Parser, " when parsing" do
-    include FSConfigurationParserTesting
-    it "should allow comments" do
-      write_config_file("# this is a comment\n")
-      expect { @parser.parse }.not_to raise_error
-    end
-    it "should allow blank lines" do
-      write_config_file("\n")
-      expect { @parser.parse }.not_to raise_error
-    end
-    it "should return a hash of the created mounts" do
-      mount1 = double('one', :validate => true)
-      mount2 = double('two', :validate => true)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("two").and_return(mount2)
-      write_config_file "[one]\n[two]\n"
-      result = @parser.parse
-      expect(result["one"]).to equal(mount1)
-      expect(result["two"]).to equal(mount2)
-    end
-    it "should only allow mount names that are alphanumeric plus dashes" do
-      write_config_file "[a*b]\n"
-      expect { @parser.parse }.to raise_error(ArgumentError)
-    end
-    it "should fail if the value for path starts with an equals sign" do
-      write_config_file "[one]\npath = /testing"
-      expect { @parser.parse }.to raise_error(ArgumentError)
-    end
-    it "should validate each created mount" do
-      mount1 = double('one')
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
-      write_config_file "[one]\n"
-      expect(mount1).to receive(:validate)
-      @parser.parse
-    end
-    it "should fail if any mount does not pass validation" do
-      mount1 = double('one')
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(mount1)
-      write_config_file "[one]\n"
-      expect(mount1).to receive(:validate).and_raise(RuntimeError)
-      expect { @parser.parse }.to raise_error(RuntimeError)
-    end
-    it "should return comprehensible error message, if invalid line detected" do
-      write_config_file "[one]\n\n\x01path /etc/puppetlabs/puppet/files\n\x01allow *\n"
-      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid entry at \(file: .*, line: 3\): .*/)
-    end
-  end
-  describe Puppet::FileServing::Configuration::Parser, " when parsing mount attributes" do
-    include FSConfigurationParserTesting
-    before do
-      @mount = double('testmount', :name => "one", :validate => true)
-      expect(Puppet::FileServing::Mount::File).to receive(:new).with("one").and_return(@mount)
-    end
-    it "should set the mount path to the path attribute from that section" do
-      write_config_file "[one]\npath /some/path\n"
-      expect(@mount).to receive(:path=).with("/some/path")
-      @parser.parse
-    end
-    [:allow,:deny].each { |acl_type|
-      it "should ignore inline comments in #{acl_type}" do
-        write_config_file "[one]\n#{acl_type} something \# will it work?\n"
-        expect(@parser.parse).to eq('one' => @mount)
-      end
-      it "should ignore #{acl_type} from ACLs with varying spacing around commas" do
-        write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
-        expect(@parser.parse).to eq('one' => @mount)
-      end
-      it "should log an error and print the location of the #{acl_type} rule" do
-        write_config_file(<<~CONFIG)
-        [one]
-        #{acl_type} one
-        CONFIG
-        expect(Puppet).to receive(:err).with(/Entry '#{acl_type} one' is unsupported and will be ignored at \(file: .*, line: 2\)/)
-        @parser.parse
-      end
-    }
-    it "should not generate an error when parsing 'allow *'" do
-      write_config_file "[one]\nallow *\n"
-      expect(Puppet).to receive(:err).never
-      @parser.parse
-    end
-    it "should return comprehensible error message, if failed on invalid attribute" do
-      write_config_file "[one]\ndo something\n"
-      expect { @parser.parse }.to raise_error(ArgumentError, /Invalid argument 'do' at \(file: .*, line: 2\)/)
-    end
-  end
-  describe Puppet::FileServing::Configuration::Parser, " when parsing the modules mount" do
-    include FSConfigurationParserTesting
-    before do
-      @mount = double('modulesmount', :name => "modules", :validate => true)
-    end
-    it "should create an instance of the Modules Mount class" do
-      write_config_file "[modules]\n"
-      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
-      @parser.parse
-    end
-    it "should warn if a path is set" do
-      write_config_file "[modules]\npath /some/path\n"
-      expect(Puppet::FileServing::Mount::Modules).to receive(:new).with("modules").and_return(@mount)
-      expect(Puppet).to receive(:warning)
-      @parser.parse
-    end
-  end
-  describe Puppet::FileServing::Configuration::Parser, " when parsing the scripts mount" do
-    include FSConfigurationParserTesting
-    before do
-      @mount = double('scriptsmount', :name => "scripts", :validate => true)
-    end
-    it "should create an instance of the Scripts Mount class" do
-      write_config_file "[scripts]\n"
-      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
-      @parser.parse
-    end
-    it "should warn if a path is set" do
-      write_config_file "[scripts]\npath /some/path\n"
-      expect(Puppet::FileServing::Mount::Scripts).to receive(:new).with("scripts").and_return(@mount)
-      expect(Puppet).to receive(:warning)
-      @parser.parse
-    end
-  end
-  describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
-    include FSConfigurationParserTesting
-    before do
-      @mount = double('pluginsmount', :name => "plugins", :validate => true)
-    end
-    it "should create an instance of the Plugins Mount class" do
-      write_config_file "[plugins]\n"
-      expect(Puppet::FileServing::Mount::Plugins).to receive(:new).with("plugins").and_return(@mount)
-      @parser.parse
-    end
-    it "should warn if a path is set" do
-      write_config_file "[plugins]\npath /some/path\n"
-      expect(Puppet).to receive(:warning)
-      @parser.parse
-    end
-  end
-end

data/spec/unit/file_serving/configuration_spec.rb DELETED Viewed

@@ -1,240 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/configuration'
-describe Puppet::FileServing::Configuration do
-  include PuppetSpec::Files
-  before :each do
-    @path = make_absolute("/path/to/configuration/file.conf")
-    Puppet[:trace] = false
-    Puppet[:fileserverconfig] = @path
-  end
-  after :each do
-    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-  end
-  it "should make :new a private method" do
-    expect { Puppet::FileServing::Configuration.new }.to raise_error(NoMethodError, /private method `new' called/)
-  end
-  it "should return the same configuration each time 'configuration' is called" do
-    expect(Puppet::FileServing::Configuration.configuration).to equal(Puppet::FileServing::Configuration.configuration)
-  end
-  describe "when initializing" do
-    it "should work without a configuration file" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(false)
-      expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
-    end
-    it "should parse the configuration file if present" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      expect(@parser).to receive(:parse).and_return({})
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
-      Puppet::FileServing::Configuration.configuration
-    end
-    it "should determine the path to the configuration file from the Puppet settings" do
-      Puppet::FileServing::Configuration.configuration
-    end
-  end
-  describe "when parsing the configuration file" do
-    before do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
-    end
-    it "should set the mount list to the results of parsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      config = Puppet::FileServing::Configuration.configuration
-      expect(config.mounted?("one")).to be_truthy
-    end
-    it "should not raise exceptions" do
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
-      expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
-    end
-    it "should replace the existing mount list with the results of reparsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      config = Puppet::FileServing::Configuration.configuration
-      expect(config.mounted?("one")).to be_truthy
-      # Now parse again
-      expect(@parser).to receive(:parse).and_return("two" => double('other'))
-      config.send(:readconfig, false)
-      expect(config.mounted?("one")).to be_falsey
-      expect(config.mounted?("two")).to be_truthy
-    end
-    it "should not replace the mount list until the file is entirely parsed successfully" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
-      config = Puppet::FileServing::Configuration.configuration
-      # Now parse again, so the exception gets thrown
-      config.send(:readconfig, false)
-      expect(config.mounted?("one")).to be_truthy
-    end
-    it "should add modules, plugins, scripts, and tasks mounts even if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      config = Puppet::FileServing::Configuration.configuration
-      expect(config.mounted?("modules")).to be_truthy
-      expect(config.mounted?("plugins")).to be_truthy
-      expect(config.mounted?("scripts")).to be_truthy
-      expect(config.mounted?("tasks")).to be_truthy
-    end
-    it "should allow all access to modules, plugins, scripts, and tasks if no fileserver.conf exists" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules')
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      plugins = double('plugins')
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      tasks = double('tasks')
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      scripts = double('scripts')
-      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
-      Puppet::FileServing::Configuration.configuration
-    end
-    it "should not allow access from all to modules, plugins, scripts, and tasks if the fileserver.conf provided some rules" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules')
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      plugins = double('plugins')
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      tasks = double('tasks')
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      scripts = double('scripts', :empty? => false)
-      allow(Puppet::FileServing::Mount::Scripts).to receive(:new).and_return(scripts)
-      Puppet::FileServing::Configuration.configuration
-    end
-    it "should add modules, plugins, scripts, and tasks mounts even if they are not returned by the parser" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(true) # the file doesn't exist
-      config = Puppet::FileServing::Configuration.configuration
-      expect(config.mounted?("modules")).to be_truthy
-      expect(config.mounted?("plugins")).to be_truthy
-      expect(config.mounted?("scripts")).to be_truthy
-      expect(config.mounted?("tasks")).to be_truthy
-    end
-  end
-  describe "when finding the specified mount" do
-    it "should choose the named mount if one exists" do
-      config = Puppet::FileServing::Configuration.configuration
-      expect(config).to receive(:mounts).and_return("one" => "foo")
-      expect(config.find_mount("one", double('env'))).to eq("foo")
-    end
-    it "should return nil if there is no such named mount" do
-      config = Puppet::FileServing::Configuration.configuration
-      env = double('environment')
-      mount = double('mount')
-      allow(config).to receive(:mounts).and_return("modules" => mount)
-      expect(config.find_mount("foo", env)).to be_nil
-    end
-  end
-  describe "#split_path" do
-    let(:config) { Puppet::FileServing::Configuration.configuration }
-    let(:request) { double('request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => double("env")) }
-    before do
-      allow(config).to receive(:find_mount)
-    end
-    it "should reread the configuration" do
-      expect(config).to receive(:readconfig)
-      config.split_path(request)
-    end
-    it "should treat the first field of the URI path as the mount name" do
-      expect(config).to receive(:find_mount).with("foo", anything)
-      config.split_path(request)
-    end
-    it "should fail if the mount name is not alpha-numeric" do
-      expect(request).to receive(:key).and_return("foo&bar/asdf")
-      expect { config.split_path(request) }.to raise_error(ArgumentError)
-    end
-    it "should support dashes in the mount name" do
-      expect(request).to receive(:key).and_return("foo-bar/asdf")
-      expect { config.split_path(request) }.to_not raise_error
-    end
-    it "should use the mount name and environment to find the mount" do
-      expect(config).to receive(:find_mount).with("foo", request.environment)
-      allow(request).to receive(:node).and_return("mynode")
-      config.split_path(request)
-    end
-    it "should return nil if the mount cannot be found" do
-      expect(config).to receive(:find_mount).and_return(nil)
-      expect(config.split_path(request)).to be_nil
-    end
-    it "should return the mount and the relative path if the mount is found" do
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
-      expect(config.split_path(request)).to eq([mount, "bar/baz"])
-    end
-    it "should remove any double slashes" do
-      allow(request).to receive(:key).and_return("foo/bar//baz")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
-      expect(config.split_path(request)).to eq([mount, "bar/baz"])
-    end
-    it "should fail if the path contains .." do
-      allow(request).to receive(:key).and_return('module/foo/../../bar')
-      expect do
-        config.split_path(request)
-      end.to raise_error(ArgumentError, /Invalid relative path/)
-    end
-    it "should return the relative path as nil if it is an empty string" do
-      expect(request).to receive(:key).and_return("foo")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
-      expect(config.split_path(request)).to eq([mount, nil])
-    end
-    it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
-      expect(request).to receive(:key).and_return("foo/bar")
-      mount = double('mount', :name => "modules")
-      expect(config).to receive(:find_mount).and_return(mount)
-      expect(config.split_path(request)).to eq([mount, "foo/bar"])
-    end
-  end
-end

data/spec/unit/file_serving/content_spec.rb DELETED Viewed

@@ -1,98 +0,0 @@
-require 'spec_helper'
-require 'puppet/file_serving/content'
-describe Puppet::FileServing::Content do
-  let(:path) { File.expand_path('/path') }
-  it "should be a subclass of Base" do
-    expect(Puppet::FileServing::Content.superclass).to equal(Puppet::FileServing::Base)
-  end
-  it "should indirect file_content" do
-    expect(Puppet::FileServing::Content.indirection.name).to eq(:file_content)
-  end
-  it "should only support the binary format" do
-    expect(Puppet::FileServing::Content.supported_formats).to eq([:binary])
-  end
-  it "should have a method for collecting its attributes" do
-    expect(Puppet::FileServing::Content.new(path)).to respond_to(:collect)
-  end
-  it "should not retrieve and store its contents when its attributes are collected" do
-    content = Puppet::FileServing::Content.new(path)
-    expect(File).not_to receive(:read).with(path)
-    content.collect
-    expect(content.instance_variable_get("@content")).to be_nil
-  end
-  it "should have a method for setting its content" do
-    content = Puppet::FileServing::Content.new(path)
-    expect(content).to respond_to(:content=)
-  end
-  it "should make content available when set externally" do
-    content = Puppet::FileServing::Content.new(path)
-    content.content = "foo/bar"
-    expect(content.content).to eq("foo/bar")
-  end
-  it "should be able to create a content instance from binary file contents" do
-    expect(Puppet::FileServing::Content).to respond_to(:from_binary)
-  end
-  it "should create an instance with a fake file name and correct content when converting from binary" do
-    instance = double('instance')
-    expect(Puppet::FileServing::Content).to receive(:new).with("/this/is/a/fake/path").and_return(instance)
-    expect(instance).to receive(:content=).with("foo/bar")
-    expect(Puppet::FileServing::Content.from_binary("foo/bar")).to equal(instance)
-  end
-  it "should return an opened File when converted to binary" do
-    content = Puppet::FileServing::Content.new(path)
-    expect(File).to receive(:new).with(path, "rb").and_return(:file)
-    expect(content.to_binary).to eq(:file)
-  end
-end
-describe Puppet::FileServing::Content, "when returning the contents" do
-  let(:path) { File.expand_path('/my/path') }
-  let(:content) { Puppet::FileServing::Content.new(path, :links => :follow) }
-  it "should fail if the file is a symlink and links are set to :manage" do
-    content.links = :manage
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double("stat", :ftype => "symlink"))
-    expect { content.content }.to raise_error(ArgumentError)
-  end
-  it "should fail if a path is not set" do
-    expect { content.content }.to raise_error(Errno::ENOENT)
-  end
-  it "should raise Errno::ENOENT if the file is absent" do
-    content.path = File.expand_path("/there/is/absolutely/no/chance/that/this/path/exists")
-    expect { content.content }.to raise_error(Errno::ENOENT)
-  end
-  it "should return the contents of the path if the file exists" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
-    expect(content.content).to eq(:mycontent)
-  end
-  it "should cache the returned contents" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
-    content.content
-    # The second run would throw a failure if the content weren't being cached.
-    content.content
-  end
-end