puppet 2.7.11 → 2.7.12

data/spec/unit/file_serving/base_spec.rb

@@ -4,8 +4,11 @@ require 'spec_helper'
 require 'puppet/file_serving/base'
 
 describe Puppet::FileServing::Base do
+  let(:path) { File.expand_path('/module/dir/file') }
+  let(:file) { File.expand_path('/my/file') }
+
   it "should accept a path" do
-    Puppet::FileServing::Base.new("/module/dir/file").path.should == "/module/dir/file"
+    Puppet::FileServing::Base.new(path).path.should == path
   end
 
   it "should require that paths be fully qualified" do
@@ -13,119 +16,134 @@ describe Puppet::FileServing::Base do
   end
 
   it "should allow specification of whether links should be managed" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => :manage).links.should == :manage
+    Puppet::FileServing::Base.new(path, :links => :manage).links.should == :manage
   end
 
   it "should have a :source attribute" do
-    file = Puppet::FileServing::Base.new("/module/dir/file")
+    file = Puppet::FileServing::Base.new(path)
     file.should respond_to(:source)
     file.should respond_to(:source=)
   end
 
   it "should consider :ignore links equivalent to :manage links" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => :ignore).links.should == :manage
+    Puppet::FileServing::Base.new(path, :links => :ignore).links.should == :manage
   end
 
   it "should fail if :links is set to anything other than :manage, :follow, or :ignore" do
-    proc { Puppet::FileServing::Base.new("/module/dir/file", :links => :else) }.should raise_error(ArgumentError)
+    proc { Puppet::FileServing::Base.new(path, :links => :else) }.should raise_error(ArgumentError)
   end
 
   it "should allow links values to be set as strings" do
-    Puppet::FileServing::Base.new("/module/dir/file", :links => "follow").links.should == :follow
+    Puppet::FileServing::Base.new(path, :links => "follow").links.should == :follow
   end
 
   it "should default to :manage for :links" do
-    Puppet::FileServing::Base.new("/module/dir/file").links.should == :manage
+    Puppet::FileServing::Base.new(path).links.should == :manage
   end
 
   it "should allow specification of a path" do
     FileTest.stubs(:exists?).returns(true)
-    Puppet::FileServing::Base.new("/module/dir/file", :path => "/my/file").path.should == "/my/file"
+    Puppet::FileServing::Base.new(path, :path => file).path.should == file
   end
 
   it "should allow specification of a relative path" do
     FileTest.stubs(:exists?).returns(true)
-    Puppet::FileServing::Base.new("/module/dir/file", :relative_path => "my/file").relative_path.should == "my/file"
+    Puppet::FileServing::Base.new(path, :relative_path => "my/file").relative_path.should == "my/file"
   end
 
   it "should have a means of determining if the file exists" do
-    Puppet::FileServing::Base.new("/blah").should respond_to(:exist?)
+    Puppet::FileServing::Base.new(file).should respond_to(:exist?)
   end
 
   it "should correctly indicate if the file is present" do
-    File.expects(:lstat).with("/my/file").returns(mock("stat"))
-    Puppet::FileServing::Base.new("/my/file").exist?.should be_true
+    File.expects(:lstat).with(file).returns(mock("stat"))
+    Puppet::FileServing::Base.new(file).exist?.should be_true
   end
 
   it "should correctly indicate if the file is absent" do
-    File.expects(:lstat).with("/my/file").raises RuntimeError
-    Puppet::FileServing::Base.new("/my/file").exist?.should be_false
+    File.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("/module/dir/file")
+      @file = Puppet::FileServing::Base.new(path)
       FileTest.stubs(:exists?).returns(true)
-      proc { @file.relative_path = "/qualified/file" }.should raise_error(ArgumentError)
+      proc { @file.relative_path = File.expand_path("/qualified/file") }.should raise_error(ArgumentError)
     end
   end
 
   describe "when determining the full file path" do
-    before do
-      @file = Puppet::FileServing::Base.new("/this/file")
-    end
+    let(:path) { File.expand_path('/this/file') }
+    let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should return the path if there is no relative path" do
-      @file.full_path.should == "/this/file"
+      file.full_path.should == path
     end
 
     it "should return the path if the relative_path is set to ''" do
-      @file.relative_path = ""
-      @file.full_path.should == "/this/file"
+      file.relative_path = ""
+      file.full_path.should == path
     end
 
     it "should return the path if the relative_path is set to '.'" do
-      @file.relative_path = "."
-      @file.full_path.should == "/this/file"
+      file.relative_path = "."
+      file.full_path.should == path
     end
 
     it "should return the path joined with the relative path if there is a relative path and it is not set to '/' or ''" do
-      @file.relative_path = "not/qualified"
-      @file.full_path.should == "/this/file/not/qualified"
+      file.relative_path = "not/qualified"
+      file.full_path.should == File.join(path, "not/qualified")
     end
 
     it "should strip extra slashes" do
-      file = Puppet::FileServing::Base.new("//this//file")
-      file.full_path.should == "/this/file"
+      file = Puppet::FileServing::Base.new(File.join(File.expand_path('/'), "//this//file"))
+      file.full_path.should == path
     end
   end
 
   describe "when stat'ing files" do
-    before do
-      @file = Puppet::FileServing::Base.new("/this/file")
-    end
+    let(:path) { File.expand_path('/this/file') }
+    let(:file) { Puppet::FileServing::Base.new(path) }
 
     it "should stat the file's full path" do
-      @file.stubs(:full_path).returns("/this/file")
-      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.stat
+      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      file.stat
     end
 
     it "should fail if the file does not exist" do
-      @file.stubs(:full_path).returns("/this/file")
-      File.expects(:lstat).with("/this/file").raises(Errno::ENOENT)
-      proc { @file.stat }.should raise_error(Errno::ENOENT)
+      File.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
-      File.expects(:lstat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.stat
+      File.expects(:lstat).with(path).returns stub("stat", :ftype => "file")
+      file.stat
     end
 
     it "should use :stat if :links is set to :follow" do
-      File.expects(:stat).with("/this/file").returns stub("stat", :ftype => "file")
-      @file.links = :follow
-      @file.stat
+      File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+      file.links = :follow
+      file.stat
+    end
+  end
+
+  describe "#absolute?" do
+    it "should be accept POSIX paths" do
+      Puppet::FileServing::Base.should be_absolute('/')
+    end
+
+    it "should accept Windows paths on Windows" do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      Puppet.features.stubs(:posix?).returns(false)
+
+      Puppet::FileServing::Base.should be_absolute('c:/foo')
+    end
+
+    it "should reject Windows paths on POSIX" do
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
+
+      Puppet::FileServing::Base.should_not be_absolute('c:/foo')
     end
   end
 end

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

@@ -14,7 +14,8 @@ module FSConfigurationParserTesting
   def mock_file_content(content)
     # We want an array, but we actually want our carriage returns on all of it.
     lines = content.split("\n").collect { |l| l + "\n" }
-    @filehandle.stubs(:each).multiple_yields(*lines)
+    @filehandle.stubs(:each_line).multiple_yields(*lines)
+    @filehandle.expects(:each).never
   end
 end
 
@@ -24,6 +25,7 @@ describe Puppet::FileServing::Configuration::Parser do
     FileTest.stubs(:exists?).with(@path).returns(true)
     FileTest.stubs(:readable?).with(@path).returns(true)
     @filehandle = mock 'filehandle'
+    @filehandle.expects(:each).never
     File.expects(:open).with(@path).yields(@filehandle)
     @parser = Puppet::FileServing::Configuration::Parser.new(@path)
   end
@@ -32,12 +34,12 @@ describe Puppet::FileServing::Configuration::Parser do
     include FSConfigurationParserTesting
 
     it "should allow comments" do
-      @filehandle.expects(:each).yields("# this is a comment\n")
+      @filehandle.expects(:each_line).yields("# this is a comment\n")
       proc { @parser.parse }.should_not raise_error
     end
 
     it "should allow blank lines" do
-      @filehandle.expects(:each).yields("\n")
+      @filehandle.expects(:each_line).yields("\n")
       proc { @parser.parse }.should_not raise_error
     end
 

data/spec/unit/file_serving/content_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'puppet/file_serving/content'
 
 describe Puppet::FileServing::Content do
+  let(:path) { File.expand_path('/path') }
+
   it "should should be a subclass of Base" do
     Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::Base)
   end
@@ -21,38 +23,38 @@ describe Puppet::FileServing::Content do
   end
 
   it "should have a method for collecting its attributes" do
-    Puppet::FileServing::Content.new("/path").should respond_to(:collect)
+    Puppet::FileServing::Content.new(path).should respond_to(:collect)
   end
 
   it "should not retrieve and store its contents when its attributes are collected if the file is a normal file" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
     File.stubs(:lstat).returns(stub("stat", :ftype => "file"))
-    File.expects(:read).with("/path").never
+    File.expects(:read).with(path).never
     content.collect
 
     content.instance_variable_get("@content").should be_nil
   end
 
   it "should not attempt to retrieve its contents if the file is a directory" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
     File.stubs(:lstat).returns(stub("stat", :ftype => "directory"))
-    File.expects(:read).with("/path").never
+    File.expects(:read).with(path).never
     content.collect
 
     content.instance_variable_get("@content").should be_nil
   end
 
   it "should have a method for setting its content" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
     content.should respond_to(:content=)
   end
 
   it "should make content available when set externally" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
     content.content = "foo/bar"
     content.content.should == "foo/bar"
   end
@@ -71,47 +73,44 @@ describe Puppet::FileServing::Content do
   end
 
   it "should return an opened File when converted to raw" do
-    content = Puppet::FileServing::Content.new("/path")
+    content = Puppet::FileServing::Content.new(path)
 
-    File.expects(:new).with("/path","rb").returns :file
+    File.expects(:new).with(path, "rb").returns :file
 
     content.to_raw.should == :file
   end
 end
 
 describe Puppet::FileServing::Content, "when returning the contents" do
-  before do
-    @path = "/my/path"
-    @content = Puppet::FileServing::Content.new(@path, :links => :follow)
-  end
+  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
-    File.expects(:lstat).with(@path).returns stub("stat", :ftype => "symlink")
-    proc { @content.content }.should raise_error(ArgumentError)
+    content.links = :manage
+    File.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
+    proc { content.content }.should raise_error(ArgumentError)
   end
 
   it "should fail if a path is not set" do
-    proc { @content.content }.should raise_error(Errno::ENOENT)
+    proc { content.content }.should raise_error(Errno::ENOENT)
   end
 
   it "should raise Errno::ENOENT if the file is absent" do
-    @content.path = "/there/is/absolutely/no/chance/that/this/path/exists"
-    proc { @content.content }.should raise_error(Errno::ENOENT)
+    content.path = File.expand_path("/there/is/absolutely/no/chance/that/this/path/exists")
+    proc { content.content }.should raise_error(Errno::ENOENT)
   end
 
   it "should return the contents of the path if the file exists" do
-    File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
-    @content.content.should == :mycontent
+    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+    IO.expects(:binread).with(path).returns(:mycontent)
+    content.content.should == :mycontent
   end
 
   it "should cache the returned contents" do
-    File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
-    Puppet::Util.expects(:binread).with(@path).returns(:mycontent)
-    @content.content
-
+    File.expects(:stat).with(path).returns stub("stat", :ftype => "file")
+    IO.expects(:binread).with(path).returns(:mycontent)
+    content.content
     # The second run would throw a failure if the content weren't being cached.
-    @content.content
+    content.content
   end
 end

data/spec/unit/file_serving/metadata_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'puppet/file_serving/metadata'
 
 describe Puppet::FileServing::Metadata do
+  let(:foobar) { File.expand_path('/foo/bar') }
+
   it "should should be a subclass of Base" do
     Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
   end
@@ -17,15 +19,15 @@ describe Puppet::FileServing::Metadata do
   end
 
   it "should have a method that triggers attribute collection" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:collect)
   end
 
   it "should support pson serialization" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson)
   end
 
   it "should support to_pson_data_hash" do
-    Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:to_pson_data_hash)
+    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson_data_hash)
   end
 
   it "should support pson deserialization" do
@@ -33,67 +35,66 @@ describe Puppet::FileServing::Metadata do
   end
 
   describe "when serializing" do
-    before do
-      @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
-    end
+    let(:metadata) { Puppet::FileServing::Metadata.new(foobar) }
+
     it "should perform pson serialization by calling to_pson on it's pson_data_hash" do
       pdh = mock "data hash"
       pdh_as_pson = mock "data as pson"
-      @metadata.expects(:to_pson_data_hash).returns pdh
+      metadata.expects(:to_pson_data_hash).returns pdh
       pdh.expects(:to_pson).returns pdh_as_pson
-      @metadata.to_pson.should == pdh_as_pson
+      metadata.to_pson.should == pdh_as_pson
     end
 
     it "should serialize as FileMetadata" do
-      @metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
+      metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
     end
 
     it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
-      @metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
+      metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
     end
 
     it "should pass the path in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['path'] == @metadata.path
+      metadata.to_pson_data_hash['data']['path'] == metadata.path
     end
 
     it "should pass the relative_path in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['relative_path'] == @metadata.relative_path
+      metadata.to_pson_data_hash['data']['relative_path'] == metadata.relative_path
     end
 
     it "should pass the links in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['links'] == @metadata.links
+      metadata.to_pson_data_hash['data']['links'] == metadata.links
     end
 
     it "should pass the path owner in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['owner'] == @metadata.owner
+      metadata.to_pson_data_hash['data']['owner'] == metadata.owner
     end
 
     it "should pass the group in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['group'] == @metadata.group
+      metadata.to_pson_data_hash['data']['group'] == metadata.group
     end
 
     it "should pass the mode in the hash verbatum" do
-      @metadata.to_pson_data_hash['data']['mode'] == @metadata.mode
+      metadata.to_pson_data_hash['data']['mode'] == metadata.mode
     end
 
     it "should pass the ftype in the hash verbatum as the 'type'" do
-      @metadata.to_pson_data_hash['data']['type'] == @metadata.ftype
+      metadata.to_pson_data_hash['data']['type'] == metadata.ftype
     end
 
     it "should pass the destination verbatum" do
-      @metadata.to_pson_data_hash['data']['destination'] == @metadata.destination
+      metadata.to_pson_data_hash['data']['destination'] == metadata.destination
     end
 
     it "should pass the checksum in the hash as a nested hash" do
-      @metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
+      metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
     end
 
     it "should pass the checksum_type in the hash verbatum as the checksum's type" do
-      @metadata.to_pson_data_hash['data']['checksum']['type'] == @metadata.checksum_type
+      metadata.to_pson_data_hash['data']['checksum']['type'] == metadata.checksum_type
     end
 
     it "should pass the checksum in the hash verbatum as the checksum's value" do
-      @metadata.to_pson_data_hash['data']['checksum']['value'] == @metadata.checksum
+      metadata.to_pson_data_hash['data']['checksum']['value'] == metadata.checksum
     end
 
   end