puppet 0.24.6 → 0.24.7

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

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/file_serving/configuration/parser'
+
+describe Puppet::FileServing::Configuration::Parser do
+    it "should subclass the LoadedFile class" do
+        Puppet::FileServing::Configuration::Parser.superclass.should equal(Puppet::Util::LoadedFile)
+    end
+end
+
+
+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)
+    end
+end
+
+describe Puppet::FileServing::Configuration::Parser do
+    before :each do
+        @path = "/my/config.conf"
+        FileTest.stubs(:exists?).with(@path).returns(true)
+        FileTest.stubs(:readable?).with(@path).returns(true)
+        @filehandle = mock 'filehandle'
+        File.expects(:open).with(@path).yields(@filehandle)
+        @parser = Puppet::FileServing::Configuration::Parser.new(@path)
+    end
+
+    describe Puppet::FileServing::Configuration::Parser, " when parsing" do
+        include FSConfigurationParserTesting
+
+        before do
+            @parser.stubs(:add_modules_mount)
+        end
+
+        it "should allow comments" do
+            @filehandle.expects(:each).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")
+            proc { @parser.parse }.should_not raise_error
+        end
+
+        it "should create a new mount for each section in the configuration" do
+            mount1 = mock 'one'
+            mount2 = mock 'two'
+            Puppet::FileServing::Mount.expects(:new).with("one").returns(mount1)
+            Puppet::FileServing::Mount.expects(:new).with("two").returns(mount2)
+            mock_file_content "[one]\n[two]\n"
+            @parser.parse
+        end
+
+        # This test is almost the exact same as the previous one.
+        it "should return a hash of the created mounts" do
+            mount1 = mock 'one'
+            mount2 = mock 'two'
+            Puppet::FileServing::Mount.expects(:new).with("one").returns(mount1)
+            Puppet::FileServing::Mount.expects(:new).with("two").returns(mount2)
+            mock_file_content "[one]\n[two]\n"
+
+            @parser.parse.should == {"one" => mount1, "two" => mount2}
+        end
+
+        it "should only allow mount names that are alphanumeric plus dashes" do
+            mock_file_content "[a*b]\n"
+            proc { @parser.parse }.should raise_error(ArgumentError)
+        end
+
+        it "should fail if the value for path/allow/deny starts with an equals sign" do
+            mock_file_content "[one]\npath = /testing"
+            proc { @parser.parse }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe Puppet::FileServing::Configuration::Parser, " when parsing mount attributes" do
+        include FSConfigurationParserTesting
+
+        before do
+            @mount = stub 'mount', :name => "one"
+            Puppet::FileServing::Mount.expects(:new).with("one").returns(@mount)
+            @parser.stubs(:add_modules_mount)
+        end
+
+        it "should set the mount path to the path attribute from that section" do
+            mock_file_content "[one]\npath /some/path\n"
+
+            @mount.expects(:path=).with("/some/path")
+            @parser.parse
+        end
+
+        it "should tell the mount to allow any allow values from the section" do
+            mock_file_content "[one]\nallow something\n"
+
+            @mount.expects(:info)
+            @mount.expects(:allow).with("something")
+            @parser.parse
+        end
+
+        it "should tell the mount to deny any deny values from the section" do
+            mock_file_content "[one]\ndeny something\n"
+
+            @mount.expects(:info)
+            @mount.expects(:deny).with("something")
+            @parser.parse
+        end
+
+        it "should fail on any attributes other than path, allow, and deny" do
+            mock_file_content "[one]\ndo something\n"
+
+            proc { @parser.parse }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe Puppet::FileServing::Configuration::Parser, " when parsing the modules mount" do
+        include FSConfigurationParserTesting
+
+        before do
+            @mount = stub 'mount', :name => "modules"
+            Puppet::FileServing::Mount.expects(:new).with("modules").returns(@mount)
+        end
+
+        it "should warn if a path is set" do
+            mock_file_content "[modules]\npath /some/path\n"
+
+            @modules.expects(:path=).never
+            Puppet.expects(:warning)
+            @parser.parse
+        end
+    end
+end

data/spec/unit/file_serving/content.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/content'
+
+describe Puppet::FileServing::Content do
+    it "should should be a subclass of FileBase" do
+        Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::FileBase)
+    end
+
+    it "should indirect file_content" do
+        Puppet::FileServing::Content.indirection.name.should == :file_content
+    end
+
+    it "should should include the IndirectionHooks module in its indirection" do
+        Puppet::FileServing::Content.indirection.metaclass.included_modules.should include(Puppet::FileServing::IndirectionHooks)
+    end
+end
+
+describe Puppet::FileServing::Content, " when returning the contents" do
+    before do
+        @path = "/my/base"
+        @content = Puppet::FileServing::Content.new("sub/path", :links => :follow, :path => @path)
+    end
+
+    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)
+    end
+
+    it "should fail if a path is not set" do
+        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)
+    end
+
+    it "should return the contents of the path if the file exists" do
+        File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
+        File.expects(:read).with(@path).returns(:mycontent)
+        @content.content.should == :mycontent
+    end
+end
+
+describe Puppet::FileServing::Content, " when converting to yaml" do
+    it "should fail if no path has been set" do
+        @content = Puppet::FileServing::Content.new("some/key")
+        proc { @content.to_yaml }.should raise_error(ArgumentError)
+    end
+
+    it "should return the file contents" do
+        @content = Puppet::FileServing::Content.new("some/path")
+        @content.path = "/base/path"
+        @content.expects(:content).returns(:content)
+        @content.to_yaml.should == :content
+    end
+end
+
+describe Puppet::FileServing::Content, " when converting from yaml" do
+    # LAK:FIXME This isn't in the right place, but we need some kind of
+    # control somewhere that requires that all REST connections only pull
+    # from the file-server, thus guaranteeing they go through our authorization
+    # hook.
+    it "should set the URI scheme to 'puppetmounts'" do
+        pending "We need to figure out where this should be"
+    end
+end

data/spec/unit/file_serving/file_base.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/file_base'
+
+describe Puppet::FileServing::FileBase do
+    it "should accept a key in the form of a URI" do
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file").key.should == "puppet://host/module/dir/file"
+    end
+
+    it "should allow specification of whether links should be managed" do
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :links => :manage).links.should == :manage
+    end
+
+    it "should consider :ignore links equivalent to :manage links" do
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :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::FileBase.new("puppet://host/module/dir/file", :links => :else) }.should raise_error(ArgumentError)
+    end
+
+    it "should default to :manage for :links" do
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file").links.should == :manage
+    end
+
+    it "should allow specification of a path" do
+        FileTest.stubs(:exists?).returns(true)
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :path => "/my/file").path.should == "/my/file"
+    end
+
+    it "should allow specification of a relative path" do
+        FileTest.stubs(:exists?).returns(true)
+        Puppet::FileServing::FileBase.new("puppet://host/module/dir/file", :relative_path => "my/file").relative_path.should == "my/file"
+    end
+
+    it "should have a means of determining if the file exists" do
+        Puppet::FileServing::FileBase.new("blah").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::FileBase.new("blah", :path => "/my/file").exist?.should be_true
+    end
+
+    it "should correctly indicate if the file is asbsent" do
+        File.expects(:lstat).with("/my/file").raises RuntimeError
+        Puppet::FileServing::FileBase.new("blah", :path => "/my/file").exist?.should be_false
+    end
+
+    describe "when setting the base path" do
+        before do
+            @file = Puppet::FileServing::FileBase.new("puppet://host/module/dir/file")
+        end
+
+        it "should require that the base path be fully qualified" do
+            FileTest.stubs(:exists?).returns(true)
+            proc { @file.path = "unqualified/file" }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "when setting the relative path" do
+        it "should require that the relative path be unqualified" do
+            @file = Puppet::FileServing::FileBase.new("puppet://host/module/dir/file")
+            FileTest.stubs(:exists?).returns(true)
+            proc { @file.relative_path = "/qualified/file" }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "when determining the full file path" do
+        before do
+            @file = Puppet::FileServing::FileBase.new("mykey", :path => "/this/file")
+        end
+
+        it "should return the path if there is no relative path" do
+            @file.full_path.should == "/this/file"
+        end
+
+        it "should return the path if the relative_path is set to ''" do
+            @file.relative_path = ""
+            @file.full_path.should == "/this/file"
+        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"
+        end
+
+        it "should should fail if there is no path set" do
+            @file = Puppet::FileServing::FileBase.new("not/qualified")
+            proc { @file.full_path }.should raise_error(ArgumentError)
+        end
+    end
+
+    describe "when stat'ing files" do
+        before do
+            @file = Puppet::FileServing::FileBase.new("mykey", :path => "/this/file")
+        end
+
+        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
+        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)
+        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
+        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
+        end
+    end
+end

data/spec/unit/file_serving/fileset.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/fileset'
+
+describe Puppet::FileServing::Fileset, " when initializing" do
+    it "should require a path" do
+        proc { Puppet::FileServing::Fileset.new }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if its path is not fully qualified" do
+        proc { Puppet::FileServing::Fileset.new("some/file") }.should raise_error(ArgumentError)
+    end
+
+    it "should fail if its path does not exist" do
+        File.expects(:lstat).with("/some/file").returns nil
+        proc { Puppet::FileServing::Fileset.new("/some/file") }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a 'recurse' option" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        set = Puppet::FileServing::Fileset.new("/some/file", :recurse => true)
+        set.recurse.should be_true
+    end
+
+    it "should accept an 'ignore' option" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        set = Puppet::FileServing::Fileset.new("/some/file", :ignore => ".svn")
+        set.ignore.should == [".svn"]
+    end
+
+    it "should accept a 'links' option" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        set = Puppet::FileServing::Fileset.new("/some/file", :links => :manage)
+        set.links.should == :manage
+    end
+
+    it "should fail if 'links' is set to anything other than :manage or :follow" do
+        proc { Puppet::FileServing::Fileset.new("/some/file", :links => :whatever) }.should raise_error(ArgumentError)
+    end
+
+    it "should default to 'false' for recurse" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        Puppet::FileServing::Fileset.new("/some/file").recurse.should == false
+    end
+
+    it "should default to an empty ignore list" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        Puppet::FileServing::Fileset.new("/some/file").ignore.should == []
+    end
+
+    it "should default to :manage for links" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        Puppet::FileServing::Fileset.new("/some/file").links.should == :manage
+    end
+end
+
+describe Puppet::FileServing::Fileset, " when determining whether to recurse" do
+    before do
+        @path = "/my/path"
+        File.expects(:lstat).with(@path).returns stub("stat")
+        @fileset = Puppet::FileServing::Fileset.new(@path)
+    end
+
+    it "should always recurse if :recurse is set to 'true'" do
+        @fileset.recurse = true
+        @fileset.recurse?(0).should be_true
+    end
+
+    it "should never recurse if :recurse is set to 'false'" do
+        @fileset.recurse = false
+        @fileset.recurse?(-1).should be_false
+    end
+
+    it "should recurse if :recurse is set to an integer and the current depth is less than that integer" do
+        @fileset.recurse = 1
+        @fileset.recurse?(0).should be_true
+    end
+
+    it "should recurse if :recurse is set to an integer and the current depth is equal to that integer" do
+        @fileset.recurse = 1
+        @fileset.recurse?(1).should be_true
+    end
+
+    it "should not recurse if :recurse is set to an integer and the current depth is greater than that integer" do
+        @fileset.recurse = 1
+        @fileset.recurse?(2).should be_false
+    end
+
+    it "should not recurse if :recurse is set to 0" do
+        @fileset.recurse = 0
+        @fileset.recurse?(-1).should be_false
+    end
+end
+
+describe Puppet::FileServing::Fileset, " when recursing" do
+    before do
+        @path = "/my/path"
+        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+        @fileset = Puppet::FileServing::Fileset.new(@path)
+
+        @dirstat = stub 'dirstat', :directory? => true
+        @filestat = stub 'filestat', :directory? => false
+    end
+
+    def mock_dir_structure(path, stat_method = :lstat)
+        File.stubs(stat_method).with(path).returns(@dirstat)
+        Dir.stubs(:entries).with(path).returns(%w{one two .svn CVS})
+
+        # Keep track of the files we're stubbing.
+        @files = %w{.}
+
+        %w{one two .svn CVS}.each do |subdir|
+            @files << subdir # relative path
+            subpath = File.join(path, subdir)
+            File.stubs(stat_method).with(subpath).returns(@dirstat)
+            Dir.stubs(:entries).with(subpath).returns(%w{.svn CVS file1 file2})
+            %w{file1 file2 .svn CVS}.each do |file|
+                @files << File.join(subdir, file) # relative path
+                File.stubs(stat_method).with(File.join(subpath, file)).returns(@filestat)
+            end
+        end
+    end
+
+    it "should recurse through the whole file tree if :recurse is set to 'true'" do
+        mock_dir_structure(@path)
+        @fileset.stubs(:recurse?).returns(true)
+        @fileset.files.sort.should == @files.sort
+    end
+
+    it "should not recurse if :recurse is set to 'false'" do
+        mock_dir_structure(@path)
+        @fileset.stubs(:recurse?).returns(false)
+        @fileset.files.should == %w{.}
+    end
+
+    # It seems like I should stub :recurse? here, or that I shouldn't stub the
+    # examples above, but...
+    it "should recurse to the level set if :recurse is set to an integer" do
+        mock_dir_structure(@path)
+        @fileset.recurse = 1
+        @fileset.files.should == %w{. one two .svn CVS}
+    end
+
+    it "should ignore the '.' and '..' directories in subdirectories" do
+        mock_dir_structure(@path)
+        @fileset.recurse = true
+        @fileset.files.sort.should == @files.sort
+    end
+
+    it "should ignore files that match a single pattern in the ignore list" do
+        mock_dir_structure(@path)
+        @fileset.recurse = true
+        @fileset.ignore = ".svn"
+        @fileset.files.find { |file| file.include?(".svn") }.should be_nil
+    end
+
+    it "should ignore files that match any of multiple patterns in the ignore list" do
+        mock_dir_structure(@path)
+        @fileset.recurse = true
+        @fileset.ignore = %w{.svn CVS}
+        @fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }.should be_nil
+    end
+
+    it "should use File.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 "should use File.lstat if :links is set to :manage" do
+        mock_dir_structure(@path, :lstat)
+        @fileset.recurse = true
+        @fileset.links = :manage
+        @fileset.files.sort.should == @files.sort
+    end
+
+    it "should succeed when paths have regexp significant characters" do
+        @path = "/my/path/rV1x2DafFr0R6tGG+1bbk++++TM"
+        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+        @fileset = Puppet::FileServing::Fileset.new(@path)
+        mock_dir_structure(@path)
+        @fileset.recurse = true
+        @fileset.files.sort.should == @files.sort
+    end
+end
+
+describe Puppet::FileServing::Fileset, " when following links that point to missing files" do
+    before do
+        @path = "/my/path"
+        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+        @fileset = Puppet::FileServing::Fileset.new(@path)
+        @fileset.links = :follow
+        @fileset.recurse = true
+
+        @stat = stub 'stat', :directory? => true
+
+        File.expects(:stat).with(@path).returns(@stat)
+        File.expects(:stat).with(File.join(@path, "mylink")).raises(Errno::ENOENT)
+        Dir.stubs(:entries).with(@path).returns(["mylink"])
+    end
+
+    it "should not fail" do
+        proc { @fileset.files }.should_not raise_error
+    end
+
+    it "should still manage the link" do
+        @fileset.files.sort.should == %w{. mylink}.sort
+    end
+end
+
+describe Puppet::FileServing::Fileset, " when ignoring" do
+    before do
+        @path = "/my/path"
+        File.expects(:lstat).with(@path).returns stub("stat", :directory? => true)
+        @fileset = Puppet::FileServing::Fileset.new(@path)
+    end
+
+    it "should use ruby's globbing to determine what files should be ignored" do
+        @fileset.ignore = ".svn"
+        File.expects(:fnmatch?).with(".svn", "my_file")
+        @fileset.ignore?("my_file")
+    end
+
+    it "should ignore files whose paths match a single provided ignore value" do
+        @fileset.ignore = ".svn"
+        File.stubs(:fnmatch?).with(".svn", "my_file").returns true
+        @fileset.ignore?("my_file").should be_true
+    end
+
+    it "should ignore files whose paths match any of multiple provided ignore values" do
+        @fileset.ignore = [".svn", "CVS"]
+        File.stubs(:fnmatch?).with(".svn", "my_file").returns false
+        File.stubs(:fnmatch?).with("CVS", "my_file").returns true
+        @fileset.ignore?("my_file").should be_true
+    end
+end