puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/face/module/uninstall_spec.rb

@@ -8,8 +8,24 @@ describe "puppet module uninstall" do
   let(:options) do
     {}
   end
+  let(:modulepath) { File.expand_path('/module/path') }
+  let(:environment) do
+    Puppet::Node::Environment.create(:env, [modulepath], '')
+  end
+  let(:expected_options) do
+    {
+      :target_dir  => modulepath,
+      :environment_instance => environment,
+    }
+  end
 
   describe "option validation" do
+    around(:each) do |example|
+      Puppet.override(:current_environment => environment) do
+        example.run
+      end
+    end
+
     context "without any options" do
       it "should require a name" do
         pattern = /wrong number of arguments/
@@ -22,39 +38,16 @@ describe "puppet module uninstall" do
       end
     end
 
-    it "should accept the --environment option" do
-      options[:environment] = "development"
-      expected_options = { :environment => 'development' }
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
-      subject.uninstall("puppetlabs-apache", options)
-    end
-
-    it "should accept the --modulepath option" do
-      options[:modulepath] = "/foo/puppet/modules"
-      expected_options = {
-        :modulepath => '/foo/puppet/modules',
-        :environment => 'production',
-      }
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
-      subject.uninstall("puppetlabs-apache", options)
-    end
-
     it "should accept the --version option" do
       options[:version] = "1.0.0"
-      expected_options = {
-        :version => '1.0.0',
-        :environment => 'production',
-      }
+      expected_options.merge!(:version => '1.0.0')
       Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
       subject.uninstall("puppetlabs-apache", options)
     end
 
     it "should accept the --force flag" do
       options[:force] = true
-      expected_options = {
-        :environment => 'production',
-        :force => true,
-      }
+      expected_options.merge!(:force => true)
       Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
       subject.uninstall("puppetlabs-apache", options)
     end

data/spec/unit/face/parser_spec.rb

@@ -8,39 +8,55 @@ describe Puppet::Face[:parser, :current] do
 
   let(:parser) { Puppet::Face[:parser, :current] }
 
-  it "validates the configured site manifest when no files are given" do
-    Puppet[:manifest] = file_containing('site.pp', "{ invalid =>")
-    from_an_interactive_terminal
+  context "from an interactive terminal" do
+    before :each do
+      from_an_interactive_terminal
+    end
 
-    expect { parser.validate() }.to exit_with(1)
-  end
+    it "validates the configured site manifest when no files are given" do
+      Puppet[:manifest] = file_containing('site.pp', "{ invalid =>")
 
-  it "validates the given file" do
-    manifest = file_containing('site.pp', "{ invalid =>")
-    from_an_interactive_terminal
+      expect { parser.validate() }.to exit_with(1)
+    end
 
-    expect { parser.validate(manifest) }.to exit_with(1)
-  end
+    it "validates the given file" do
+      manifest = file_containing('site.pp', "{ invalid =>")
 
-  it "validates the contents of STDIN when no files given and STDIN is not a tty" do
-    from_a_piped_input_of("{ invalid =>")
+      expect { parser.validate(manifest) }.to exit_with(1)
+    end
 
-    expect { parser.validate() }.to exit_with(1)
-  end
+    it "runs error free when there are no validation errors" do
+      manifest = file_containing('site.pp', "notify { valid: }")
 
-  it "runs error free when there are no validation errors" do
-    manifest = file_containing('site.pp', "notify { valid: }")
-    from_an_interactive_terminal
+      parser.validate(manifest)
+    end
+
+    it "reports missing files" do
+      expect do
+        parser.validate("missing.pp")
+      end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
+    end
+
+    it "parses supplied manifest files in the context of a directory environment" do
+      manifest = file_containing('test.pp', "{ invalid =>")
+
+      env_loader = Puppet::Environments::Static.new(
+        Puppet::Node::Environment.create(:special, [], '')
+      )
+      Puppet.override(:environments => env_loader) do
+        Puppet[:environment] = 'special'
+        expect { parser.validate(manifest) }.to exit_with(1)
+      end
+
+      expect(@logs.join).to match(/environment special.*Syntax error at '\{'/)
+    end
 
-    parser.validate(manifest)
   end
 
-  it "reports missing files" do
-    from_an_interactive_terminal
+  it "validates the contents of STDIN when no files given and STDIN is not a tty" do
+    from_a_piped_input_of("{ invalid =>")
 
-    expect do
-      parser.validate("missing.pp")
-    end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
+    expect { parser.validate() }.to exit_with(1)
   end
 
   def from_an_interactive_terminal

data/spec/unit/file_bucket/dipper_spec.rb

@@ -45,7 +45,7 @@ describe Puppet::FileBucket::Dipper do
     Digest::MD5.hexdigest("my\r\ncontents").should == checksum
 
     @dipper.backup(file).should == checksum
-    Puppet::FileSystem::File.exist?("#{file_bucket}/f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea/contents").should == true
+    Puppet::FileSystem.exist?("#{file_bucket}/f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea/contents").should == true
   end
 
   it "should not backup a file that is already in the bucket" do
@@ -123,7 +123,7 @@ describe Puppet::FileBucket::Dipper do
         klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(contents))
 
         dipper.restore(dest, md5).should == md5
-        Digest::MD5.hexdigest(Puppet::FileSystem::File.new(dest).binread).should == md5
+        Digest::MD5.hexdigest(Puppet::FileSystem.binread(dest)).should == md5
 
         request.key.should == "md5/#{md5}"
         request.server.should == server

data/spec/unit/file_serving/base_spec.rb

@@ -42,12 +42,12 @@ describe Puppet::FileServing::Base do
   end
 
   it "should allow specification of a path" do
-    Puppet::FileSystem::File.stubs(:exist?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
     Puppet::FileServing::Base.new(path, :path => file).path.should == file
   end
 
   it "should allow specification of a relative path" do
-    Puppet::FileSystem::File.stubs(:exist?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
     Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path.should == "my/file"
   end
 
@@ -56,22 +56,19 @@ describe Puppet::FileServing::Base do
   end
 
   it "should correctly indicate if the file is present" do
-    mock_file = mock(file, :lstat => stub('stat'))
-    Puppet::FileSystem::File.expects(:new).with(file).returns mock_file
+    Puppet::FileSystem.expects(:lstat).with(file).returns stub('stat')
     Puppet::FileServing::Base.new(file).exist?.should be_true
   end
 
   it "should correctly indicate if the file is absent" do
-    mock_file = mock(file)
-    Puppet::FileSystem::File.expects(:new).with(file).returns mock_file
-    mock_file.expects(:lstat).raises RuntimeError
+    Puppet::FileSystem.expects(:lstat).with(file).raises RuntimeError
     Puppet::FileServing::Base.new(file).exist?.should be_false
   end
 
   describe "when setting the relative path" do
     it "should require that the relative path be unqualified" do
       @file = Puppet::FileServing::Base.new(path)
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       proc { @file.relative_path = File.expand_path("/qualified/file") }.should raise_error(ArgumentError)
     end
   end
@@ -129,23 +126,22 @@ describe Puppet::FileServing::Base do
     let(:stubbed_file) { stub(path, :stat => stat, :lstat => stat)}
 
     it "should stat the file's full path" do
-      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
+      Puppet::FileSystem.expects(:lstat).with(path).returns stat
       file.stat
     end
 
     it "should fail if the file does not exist" do
-      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
-      stubbed_file.expects(:lstat).raises(Errno::ENOENT)
+      Puppet::FileSystem.expects(:lstat).with(path).raises(Errno::ENOENT)
       proc { file.stat }.should raise_error(Errno::ENOENT)
     end
 
     it "should use :lstat if :links is set to :manage" do
-      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
+      Puppet::FileSystem.expects(:lstat).with(path).returns stubbed_file
       file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      Puppet::FileSystem::File.expects(:new).with(path).returns stubbed_file
+      Puppet::FileSystem.expects(:stat).with(path).returns stubbed_file
       file.links = :follow
       file.stat
     end

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

@@ -84,6 +84,12 @@ describe Puppet::FileServing::Configuration::Parser do
 
       lambda { @parser.parse }.should raise_error(RuntimeError)
     end
+
+    it "should return comprehensible error message, if invalid line detected" do
+      write_config_file "[one]\n\n\x01path /etc/puppet/files\n\x01allow *\n"
+
+      proc { @parser.parse }.should raise_error(ArgumentError, /Invalid line.*in.*, line 3/)
+    end
   end
 
   describe Puppet::FileServing::Configuration::Parser, " when parsing mount attributes" do
@@ -126,10 +132,10 @@ describe Puppet::FileServing::Configuration::Parser do
       @parser.parse
     end
 
-    it "should fail on any attributes other than path, allow, and deny" do
+    it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"
 
-      proc { @parser.parse }.should raise_error(ArgumentError)
+      proc { @parser.parse }.should raise_error(ArgumentError, /Invalid argument 'do' in .*, line 2/)
     end
   end
 

data/spec/unit/file_serving/configuration_spec.rb

@@ -27,12 +27,12 @@ describe Puppet::FileServing::Configuration do
   describe "when initializing" do
 
     it "should work without a configuration file" do
-      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(false)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(false)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should parse the configuration file if present" do
-      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
       @parser = mock 'parser'
       @parser.expects(:parse).returns({})
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
@@ -47,7 +47,7 @@ describe Puppet::FileServing::Configuration do
   describe "when parsing the configuration file" do
 
     before do
-      Puppet::FileSystem::File.stubs(:exist?).with(@path).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
       @parser = mock 'parser'
       Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
@@ -84,14 +84,14 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should add modules and plugins mounts even if the file does not exist" do
-      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true
     end
 
     it "should allow all access to modules and plugins if no fileserver.conf exists" do
-      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
       modules = stub 'modules', :empty? => true
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
       modules.expects(:allow).with('*')
@@ -104,7 +104,7 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should not allow access from all to modules and plugins if the fileserver.conf provided some rules" do
-      Puppet::FileSystem::File.expects(:exist?).returns false # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
 
       modules = stub 'modules', :empty? => false
       Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
@@ -119,7 +119,7 @@ describe Puppet::FileServing::Configuration do
 
     it "should add modules and plugins mounts even if they are not returned by the parser" do
       @parser.expects(:parse).returns("one" => mock("mount"))
-      Puppet::FileSystem::File.expects(:exist?).returns true # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       config.mounted?("modules").should be_true
       config.mounted?("plugins").should be_true

data/spec/unit/file_serving/content_spec.rb

@@ -26,8 +26,7 @@ describe Puppet::FileServing::Content do
     content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
-    stub_file = stub(path, :lstat => stub('stat', :ftype => "file"))
-    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+    Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat', :ftype => "file")
     File.expects(:read).with(path).never
     content.collect
 
@@ -38,8 +37,7 @@ describe Puppet::FileServing::Content do
     content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
-    stub_file = stub(path, :lstat => stub('stat', :ftype => "directory"))
-    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+    Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat', :ftype => "directory")
     File.expects(:read).with(path).never
     content.collect
 
@@ -85,8 +83,7 @@ describe Puppet::FileServing::Content, "when returning the contents" do
 
   it "should fail if the file is a symlink and links are set to :manage" do
     content.links = :manage
-    stub_file = stub(path, :lstat => stub("stat", :ftype => "symlink"))
-    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+    Puppet::FileSystem.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
     proc { content.content }.should raise_error(ArgumentError)
   end
 
@@ -100,16 +97,14 @@ describe Puppet::FileServing::Content, "when returning the contents" do
   end
 
   it "should return the contents of the path if the file exists" do
-    mocked_file = mock(path, :stat => stub('stat', :ftype => 'file'))
-    Puppet::FileSystem::File.expects(:new).with(path).twice.returns(mocked_file)
-    mocked_file.expects(:binread).returns(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     content.content.should == :mycontent
   end
 
   it "should cache the returned contents" do
-    mocked_file = mock(path, :stat => stub('stat', :ftype => 'file'))
-    Puppet::FileSystem::File.expects(:new).with(path).twice.returns(mocked_file)
-    mocked_file.expects(:binread).returns(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     content.content
     # The second run would throw a failure if the content weren't being cached.
     content.content

data/spec/unit/file_serving/fileset_spec.rb

@@ -18,58 +18,49 @@ describe Puppet::FileServing::Fileset do
 
     it "removes a trailing file path separator" do
       path_with_separator = "#{somefile}#{File::SEPARATOR}"
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path_with_separator)
       fileset.path.should == somefile
     end
 
     it "can be created from the root directory" do
       path = File.expand_path(File::SEPARATOR)
-      stub_file = stub(path, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path)
       fileset.path.should == path
     end
 
     it "fails if its path does not exist" do
-      mock_file = mock(somefile)
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns mock_file
-      mock_file.expects(:lstat).raises(Errno::ENOENT)
+      Puppet::FileSystem.expects(:lstat).with(somefile).raises(Errno::ENOENT)
       expect { Puppet::FileServing::Fileset.new(somefile) }.to raise_error(ArgumentError, "Fileset paths must exist")
     end
 
     it "accepts a 'recurse' option" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurse => true)
       set.recurse.should be_true
     end
 
     it "accepts a 'recurselimit' option" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3)
       set.recurselimit.should == 3
     end
 
     it "accepts an 'ignore' option" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
       set.ignore.should == [".svn"]
     end
 
     it "accepts a 'links' option" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :links => :manage)
       set.links.should == :manage
     end
 
     it "accepts a 'checksum_type' option" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :checksum_type => :test)
       set.checksum_type.should == :test
     end
@@ -79,26 +70,22 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "defaults to 'false' for recurse" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       Puppet::FileServing::Fileset.new(somefile).recurse.should == false
     end
 
     it "defaults to :infinite for recurselimit" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       Puppet::FileServing::Fileset.new(somefile).recurselimit.should == :infinite
     end
 
     it "defaults to an empty ignore list" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       Puppet::FileServing::Fileset.new(somefile).ignore.should == []
     end
 
     it "defaults to :manage for links" do
-      stub_file = stub(somefile, :lstat => stub('stat'))
-      Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       Puppet::FileServing::Fileset.new(somefile).links.should == :manage
     end
 
@@ -107,7 +94,7 @@ describe Puppet::FileServing::Fileset do
       let(:stub_file) { stub(somefile, :lstat => stub('stat')) }
 
       before :each do
-        Puppet::FileSystem::File.expects(:new).with(somefile).returns stub_file
+        Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       end
 
       [:recurse, :recurselimit, :ignore, :links].each do |option|
@@ -144,8 +131,8 @@ describe Puppet::FileServing::Fileset do
   context "when recursing" do
     before do
       @path = make_absolute("/my/path")
-      @stub_file = stub(@path, :lstat => stub('stat', :directory? => true))
-      Puppet::FileSystem::File.stubs(:new).with(@path).returns @stub_file
+      Puppet::FileSystem.stubs(:lstat).with(@path).returns stub('stat', :directory? => true)
+
       @fileset = Puppet::FileServing::Fileset.new(@path)
 
       @dirstat = stub 'dirstat', :directory? => true
@@ -153,23 +140,24 @@ describe Puppet::FileServing::Fileset do
     end
 
     def mock_dir_structure(path, stat_method = :lstat)
-      @stub_file.stubs(stat_method).returns(@dirstat)
-      Dir.stubs(:entries).with(path).returns(%w{one two .svn CVS})
+      Puppet::FileSystem.stubs(stat_method).with(path).returns @dirstat
 
       # Keep track of the files we're stubbing.
       @files = %w{.}
 
-      %w{one two .svn CVS}.each do |subdir|
+      top_names = %w{one two .svn CVS}
+      sub_names = %w{file1 file2 .svn CVS 0 false}
+
+      Dir.stubs(:entries).with(path).returns(top_names)
+      top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
-        stub_subpath = stub(subpath, stat_method => @dirstat)
-        Puppet::FileSystem::File.stubs(:new).with(subpath).returns stub_subpath
-        Dir.stubs(:entries).with(subpath).returns(%w{.svn CVS file1 file2})
-        %w{file1 file2 .svn CVS}.each do |file|
+        Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
+        Dir.stubs(:entries).with(subpath).returns(sub_names)
+        sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
-          stub_subfile_path = stub(subfile_path, stat_method => @filestat)
-          Puppet::FileSystem::File.stubs(:new).with(subfile_path).returns stub_subfile_path
+          Puppet::FileSystem.stubs(stat_method).with(subfile_path).returns(@filestat)
         end
       end
     end
@@ -185,8 +173,7 @@ describe Puppet::FileServing::Fileset do
       def mock(base_path)
         extend Mocha::API
         path = File.join(base_path, name)
-        stub_dir = stub(path, :lstat => MockStat.new(path, true))
-        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_dir
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
         Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
         entries.each do |entry|
           entry.mock(path)
@@ -198,8 +185,7 @@ describe Puppet::FileServing::Fileset do
       def mock(base_path)
         extend Mocha::API
         path = File.join(base_path, name)
-        stub_file = stub(path, :lstat => MockStat.new(path, false))
-        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_file
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, false)
       end
     end
 
@@ -261,14 +247,28 @@ describe Puppet::FileServing::Fileset do
       @fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }.should be_nil
     end
 
-    it "uses Puppet::FileSystem::File#stat if :links is set to :follow" do
+    it "ignores files that match a pattern given as a number" do
+      mock_dir_structure(@path)
+      @fileset.recurse = true
+      @fileset.ignore = [0]
+      @fileset.files.find { |file| file.include?("0") }.should be_nil
+    end
+
+    it "ignores files that match a pattern given as a boolean" do
+      mock_dir_structure(@path)
+      @fileset.recurse = true
+      @fileset.ignore = [false]
+      @fileset.files.find { |file| file.include?("false") }.should be_nil
+    end
+
+    it "uses Puppet::FileSystem#stat if :links is set to :follow" do
       mock_dir_structure(@path, :stat)
       @fileset.recurse = true
       @fileset.links = :follow
       @fileset.files.sort.should == @files.sort
     end
 
-    it "uses Puppet::FileSystem::File#lstat if :links is set to :manage" do
+    it "uses Puppet::FileSystem#lstat if :links is set to :manage" do
       mock_dir_structure(@path, :lstat)
       @fileset.recurse = true
       @fileset.links = :manage
@@ -279,7 +279,7 @@ describe Puppet::FileServing::Fileset do
       @path = make_absolute("/my/path/rV1x2DafFr0R6tGG+1bbk++++TM")
       stat = stub('dir_stat', :directory? => true)
       stub_file = stub(@path, :stat => stat, :lstat => stat)
-      Puppet::FileSystem::File.expects(:new).with(@path).twice.returns stub_file
+      Puppet::FileSystem.expects(:lstat).with(@path).returns stub(@path, :stat => stat, :lstat => stat)
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)
       @fileset.recurse = true
@@ -291,13 +291,11 @@ describe Puppet::FileServing::Fileset do
     path = make_absolute("/my/path")
     stat = stub 'stat', :directory? => true
 
-    mock_file = mock(path, :lstat => stat, :stat => stat)
-    Puppet::FileSystem::File.expects(:new).with(path).twice.returns mock_file
+    Puppet::FileSystem.expects(:stat).with(path).returns stat
+    Puppet::FileSystem.expects(:lstat).with(path).returns stat
 
     link_path = File.join(path, "mylink")
-    mock_link = mock(link_path)
-    Puppet::FileSystem::File.expects(:new).with(link_path).returns mock_link
-    mock_link.expects(:stat).raises(Errno::ENOENT)
+    Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
     Dir.stubs(:entries).with(path).returns(["mylink"])
 
@@ -312,12 +310,10 @@ describe Puppet::FileServing::Fileset do
   context "when merging other filesets" do
     before do
       @paths = [make_absolute("/first/path"), make_absolute("/second/path"), make_absolute("/third/path")]
-      stub_file = stub(:lstat => stub('stat', :directory? => false))
-      Puppet::FileSystem::File.stubs(:new).returns stub_file
+      Puppet::FileSystem.stubs(:lstat).returns stub('stat', :directory? => false)
 
       @filesets = @paths.collect do |path|
-        stub_dir = stub(path, :lstat => stub('stat', :directory? => true))
-        Puppet::FileSystem::File.stubs(:new).with(path).returns stub_dir
+        Puppet::FileSystem.stubs(:lstat).with(path).returns stub('stat', :directory? => true)
         Puppet::FileServing::Fileset.new(path, :recurse => true)
       end