puppet 0.24.9 → 0.25.0

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

@@ -32,10 +32,6 @@ describe Puppet::FileServing::Configuration::Parser do
     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
@@ -47,23 +43,25 @@ describe Puppet::FileServing::Configuration::Parser do
         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)
+            mount1 = mock 'one', :validate => true
+            mount2 = mock 'two', :validate => true
+            Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+            Puppet::FileServing::Mount::File.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)
+            mount1 = mock 'one', :validate => true
+            mount2 = mock 'two', :validate => true
+            Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+            Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
             mock_file_content "[one]\n[two]\n"
 
-            @parser.parse.should == {"one" => mount1, "two" => mount2}
+            result = @parser.parse
+            result["one"].should equal(mount1)
+            result["two"].should equal(mount2)
         end
 
         it "should only allow mount names that are alphanumeric plus dashes" do
@@ -75,14 +73,34 @@ describe Puppet::FileServing::Configuration::Parser do
             mock_file_content "[one]\npath = /testing"
             proc { @parser.parse }.should raise_error(ArgumentError)
         end
+
+        it "should validate each created mount" do
+            mount1 = mock 'one'
+            Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+            mock_file_content "[one]\n"
+
+            mount1.expects(:validate)
+
+            @parser.parse
+        end
+
+        it "should fail if any mount does not pass validation" do
+            mount1 = mock 'one'
+            Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
+            mock_file_content "[one]\n"
+
+            mount1.expects(:validate).raises RuntimeError
+
+            lambda { @parser.parse }.should raise_error(RuntimeError)
+        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)
+            @mount = stub 'testmount', :name => "one", :validate => true
+            Puppet::FileServing::Mount::File.expects(:new).with("one").returns(@mount)
             @parser.stubs(:add_modules_mount)
         end
 
@@ -120,14 +138,42 @@ describe Puppet::FileServing::Configuration::Parser do
         include FSConfigurationParserTesting
 
         before do
-            @mount = stub 'mount', :name => "modules"
-            Puppet::FileServing::Mount.expects(:new).with("modules").returns(@mount)
+            @mount = stub 'modulesmount', :name => "modules", :validate => true
+        end
+
+        it "should create an instance of the Modules Mount class" do
+            mock_file_content "[modules]\n"
+
+            Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
+            @parser.parse
         end
 
         it "should warn if a path is set" do
             mock_file_content "[modules]\npath /some/path\n"
+            Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
+
+            Puppet.expects(:warning)
+            @parser.parse
+        end
+    end
+
+    describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
+        include FSConfigurationParserTesting
+
+        before do
+            @mount = stub 'pluginsmount', :name => "plugins", :validate => true
+        end
+
+        it "should create an instance of the Plugins Mount class" do
+            mock_file_content "[plugins]\n"
+
+            Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
+            @parser.parse
+        end
+
+        it "should warn if a path is set" do
+            mock_file_content "[plugins]\npath /some/path\n"
 
-            @modules.expects(:path=).never
             Puppet.expects(:warning)
             @parser.parse
         end

data/spec/unit/file_serving/content.rb

@@ -5,8 +5,8 @@ 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)
+    it "should should be a subclass of Base" do
+        Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::Base)
     end
 
     it "should indirect file_content" do
@@ -16,12 +16,66 @@ describe Puppet::FileServing::Content do
     it "should should include the IndirectionHooks module in its indirection" do
         Puppet::FileServing::Content.indirection.metaclass.included_modules.should include(Puppet::FileServing::IndirectionHooks)
     end
+
+    it "should only support the raw format" do
+        Puppet::FileServing::Content.supported_formats.should == [:raw]
+    end
+
+    it "should have a method for collecting its attributes" do
+        Puppet::FileServing::Content.new("/path").should respond_to(:collect)
+    end
+
+    it "should retrieve and store its contents when its attributes are collected if the file is a normal file" do
+        content = Puppet::FileServing::Content.new("/path")
+
+        result = "foo"
+        File.stubs(:lstat).returns(stub("stat", :ftype => "file"))
+        File.expects(:read).with("/path").returns result
+        content.collect
+
+        content.instance_variable_get("@content").should_not be_nil
+    end
+
+    it "should not attempt to retrieve its contents if the file is a directory" do
+        content = Puppet::FileServing::Content.new("/path")
+
+        result = "foo"
+        File.stubs(:lstat).returns(stub("stat", :ftype => "directory"))
+        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.should respond_to(:content=)
+    end
+
+    it "should make content available when set externally" do
+        content = Puppet::FileServing::Content.new("/path")
+        content.content = "foo/bar"
+        content.content.should == "foo/bar"
+    end
+
+    it "should be able to create a content instance from raw file contents" do
+        Puppet::FileServing::Content.should respond_to(:from_raw)
+    end
+
+    it "should create an instance with a fake file name and correct content when converting from raw" do
+        instance = mock 'instance'
+        Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
+
+        instance.expects(:content=).with "foo/bar"
+
+        Puppet::FileServing::Content.from_raw("foo/bar").should equal(instance)
+    end
 end
 
-describe Puppet::FileServing::Content, " when returning the contents" do
+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)
+        @path = "/my/path"
+        @content = Puppet::FileServing::Content.new(@path, :links => :follow)
     end
 
     it "should fail if the file is a symlink and links are set to :manage" do
@@ -44,28 +98,13 @@ describe Puppet::FileServing::Content, " when returning the contents" do
         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
+    it "should cache the returned contents" do
+        File.expects(:stat).with(@path).returns stub("stat", :ftype => "file")
+        File.expects(:read).with(@path).returns(:mycontent)
+        @content.content
 
-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"
+        # The second run would throw a failure if the content weren't being cached.
+        @content.content
     end
 end

data/spec/unit/file_serving/fileset.rb

@@ -24,6 +24,12 @@ describe Puppet::FileServing::Fileset, " when initializing" do
         set.recurse.should be_true
     end
 
+    it "should accept a 'recurselimit' option" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        set = Puppet::FileServing::Fileset.new("/some/file", :recurselimit => 3)
+        set.recurselimit.should == 3
+    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")
@@ -45,6 +51,11 @@ describe Puppet::FileServing::Fileset, " when initializing" do
         Puppet::FileServing::Fileset.new("/some/file").recurse.should == false
     end
 
+    it "should default to :infinite for recurselimit" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        Puppet::FileServing::Fileset.new("/some/file").recurselimit.should == :infinite
+    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 == []
@@ -54,6 +65,47 @@ describe Puppet::FileServing::Fileset, " when initializing" do
         File.expects(:lstat).with("/some/file").returns stub("stat")
         Puppet::FileServing::Fileset.new("/some/file").links.should == :manage
     end
+
+    it "should support using an Indirector Request for its options" do
+        File.expects(:lstat).with("/some/file").returns stub("stat")
+        request = Puppet::Indirector::Request.new(:file_serving, :find, "foo")
+        lambda { Puppet::FileServing::Fileset.new("/some/file", request) }.should_not raise_error
+    end
+
+    describe "using an indirector request" do
+        before do
+            File.stubs(:lstat).returns stub("stat")
+            @values = {:links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234}
+            @request = Puppet::Indirector::Request.new(:file_serving, :find, "foo")
+        end
+
+        [:recurse, :recurselimit, :ignore, :links].each do |option|
+            it "should pass :recurse, :recurselimit, :ignore, and :links settings on to the fileset if present" do
+                @request.stubs(:options).returns(option => @values[option])
+                Puppet::FileServing::Fileset.new("/my/file", @request).send(option).should == @values[option]
+            end
+
+            it "should pass :recurse, :recurselimit, :ignore, and :links settings on to the fileset if present with the keys stored as strings" do
+                @request.stubs(:options).returns(option.to_s => @values[option])
+                Puppet::FileServing::Fileset.new("/my/file", @request).send(option).should == @values[option]
+            end
+        end
+
+        it "should convert the integer as a string to their integer counterpart when setting options" do
+            @request.stubs(:options).returns(:recurselimit => "1234")
+            Puppet::FileServing::Fileset.new("/my/file", @request).recurselimit.should == 1234
+        end
+
+        it "should convert the string 'true' to the boolean true when setting options" do
+            @request.stubs(:options).returns(:recurse => "true")
+            Puppet::FileServing::Fileset.new("/my/file", @request).recurse.should == true
+        end
+
+        it "should convert the string 'false' to the boolean false when setting options" do
+            @request.stubs(:options).returns(:recurse => "false")
+            Puppet::FileServing::Fileset.new("/my/file", @request).recurse.should == false
+        end
+    end
 end
 
 describe Puppet::FileServing::Fileset, " when determining whether to recurse" do
@@ -63,8 +115,9 @@ describe Puppet::FileServing::Fileset, " when determining whether to recurse" do
         @fileset = Puppet::FileServing::Fileset.new(@path)
     end
 
-    it "should always recurse if :recurse is set to 'true'" do
+    it "should always recurse if :recurse is set to 'true' and with infinite recursion" do
         @fileset.recurse = true
+        @fileset.recurselimit = :infinite
         @fileset.recurse?(0).should be_true
     end
 
@@ -73,25 +126,23 @@ describe Puppet::FileServing::Fileset, " when determining whether to recurse" do
         @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
+    it "should recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is less than that integer" do
+        @fileset.recurse = true
+        @fileset.recurselimit = 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
+    it "should recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is equal to that integer" do
+        @fileset.recurse = true
+        @fileset.recurselimit = 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
+    it "should not recurse if :recurse is set to true, :recurselimit is set to an integer and the current depth is greater than that integer" do
+        @fileset.recurse = true
+        @fileset.recurselimit = 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
@@ -137,9 +188,10 @@ describe Puppet::FileServing::Fileset, " when recursing" do
 
     # 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
+    it "should recurse to the level set if :recurselimit is set to an integer" do
         mock_dir_structure(@path)
-        @fileset.recurse = 1
+        @fileset.recurse = true
+        @fileset.recurselimit = 1
         @fileset.files.should == %w{. one two .svn CVS}
     end
 
@@ -149,6 +201,13 @@ describe Puppet::FileServing::Fileset, " when recursing" do
         @fileset.files.sort.should == @files.sort
     end
 
+    it "should function if the :ignore value provided is nil" do
+        mock_dir_structure(@path)
+        @fileset.recurse = true
+        @fileset.ignore = nil
+        lambda { @fileset.files }.should_not raise_error
+    end
+
     it "should ignore files that match a single pattern in the ignore list" do
         mock_dir_structure(@path)
         @fileset.recurse = true
@@ -237,3 +296,46 @@ describe Puppet::FileServing::Fileset, " when ignoring" do
         @fileset.ignore?("my_file").should be_true
     end
 end
+
+describe Puppet::FileServing::Fileset, "when merging other filesets" do
+    before do
+        @paths = %w{/first/path /second/path /third/path}
+
+        @filesets = @paths.collect do |path|
+            File.stubs(:lstat).with(path).returns stub("stat", :directory? => true)
+            Puppet::FileServing::Fileset.new(path, :recurse => true)
+        end
+
+        Dir.stubs(:entries).returns []
+    end
+
+    it "should return a hash of all files in each fileset with the value being the base path" do
+        Dir.expects(:entries).with("/first/path").returns(%w{one uno})
+        Dir.expects(:entries).with("/second/path").returns(%w{two dos})
+        Dir.expects(:entries).with("/third/path").returns(%w{three tres})
+
+        Puppet::FileServing::Fileset.merge(*@filesets).should == {
+            "." => "/first/path",
+            "one" => "/first/path",
+            "uno" => "/first/path",
+            "two" => "/second/path",
+            "dos" => "/second/path",
+            "three" => "/third/path",
+            "tres" => "/third/path",
+        }
+    end
+
+    it "should include the base directory from the first fileset" do
+        Dir.expects(:entries).with("/first/path").returns(%w{one})
+        Dir.expects(:entries).with("/second/path").returns(%w{two})
+
+        Puppet::FileServing::Fileset.merge(*@filesets)["."].should == "/first/path"
+    end
+
+    it "should use the base path of the first found file when relative file paths conflict" do
+        Dir.expects(:entries).with("/first/path").returns(%w{one})
+        Dir.expects(:entries).with("/second/path").returns(%w{one})
+
+        Puppet::FileServing::Fileset.merge(*@filesets)["one"].should == "/first/path"
+    end
+end

data/spec/unit/file_serving/indirection_hooks.rb

@@ -12,113 +12,52 @@ describe Puppet::FileServing::IndirectionHooks do
         @object = Object.new
         @object.extend(Puppet::FileServing::IndirectionHooks)
 
-        @request = stub 'request', :key => "http://myhost/blah", :options => {:node => "whatever"}
+        @request = stub 'request', :key => "mymod/myfile", :options => {:node => "whatever"}, :server => nil, :protocol => nil
     end
 
     describe "when being used to select termini" do
-        it "should escape the key before parsing" do
-            uri = stub 'uri', :scheme => "puppet", :host => "blah", :path => "/something"
-            URI.expects(:escape).with("http://myhost/blah").returns("escaped_blah")
-            URI.expects(:parse).with("escaped_blah").returns(uri)
-            @object.select_terminus(@request)
-        end
-
-        it "should use the URI class to parse the key" do
-            uri = stub 'uri', :scheme => "puppet", :host => "blah", :path => "/something"
-            URI.expects(:parse).with("http://myhost/blah").returns(uri)
-            @object.select_terminus @request
-        end
-
-        it "should choose :rest when the protocol is 'puppet'" do
-            @request.stubs(:key).returns "puppet://host/module/file"
-            @object.select_terminus(@request).should == :rest
-        end
-
-        it "should choose :file_server when the protocol is 'puppetmounts' and the mount name is not 'modules'" do
-            modules = mock 'modules'
-            @object.stubs(:terminus).with(:modules).returns(modules)
-            modules.stubs(:find_module).returns(nil)
-
-            @request.stubs(:key).returns "puppetmounts://host/notmodules/file"
-
-            @object.select_terminus(@request).should == :file_server
-        end
-
-        it "should choose :file_server when no server name is provided, the process name is 'puppet', and the mount name is not 'modules'" do
-            modules = mock 'modules'
-            @object.stubs(:terminus).with(:modules).returns(modules)
-            modules.stubs(:find_module).returns(nil)
-
-            Puppet.settings.expects(:value).with(:name).returns("puppet")
-            @request.stubs(:key).returns "puppet:///notmodules/file"
-            @object.select_terminus(@request).should == :file_server
-        end
-
-        it "should choose :modules if it would normally choose :file_server but the mount name is 'modules'" do
-            @request.stubs(:key).returns "puppetmounts://host/modules/mymod/file"
-            @object.select_terminus(@request).should == :modules
-        end
-
-        it "should choose :modules if it would normally choose :file_server but a module exists with the mount name" do
-            modules = mock 'modules'
-
-            @object.expects(:terminus).with(:modules).returns(modules)
-            modules.expects(:find_module).with("mymod", @request.options[:node]).returns(:thing)
-
-            @request.stubs(:key).returns "puppetmounts://host/mymod/file"
-            @object.select_terminus(@request).should == :modules
-        end
-
-        it "should choose :rest when no server name is provided and the process name is not 'puppet'" do
-            Puppet.settings.expects(:value).with(:name).returns("puppetd")
-            @request.stubs(:key).returns "puppet:///module/file"
-            @object.select_terminus(@request).should == :rest
-        end
-
-        it "should choose :file when the protocol is 'file'" do
-            @request.stubs(:key).returns "file://host/module/file"
-            @object.select_terminus(@request).should == :file
-        end
-
-        it "should choose :file when the URI is a normal path name" do
-            @request.stubs(:key).returns "/module/file"
+        it "should return :file if the request key is fully qualified" do
+            @request.expects(:key).returns "#{File::SEPARATOR}foo"
             @object.select_terminus(@request).should == :file
         end
 
-        # This is so that we only choose modules over mounts, not file
-        it "should choose :file when the protocol is 'file' and the fully qualified path starts with '/modules'" do
-            @request.stubs(:key).returns "/module/file"
+        it "should return :file if the URI protocol is set to 'file'" do
+            @request.expects(:protocol).returns "file"
             @object.select_terminus(@request).should == :file
         end
 
-        it "should fail when a protocol other than :puppet, :file, or :puppetmounts is used" do
-            @request.stubs(:key).returns "http:///module/file"
+        it "should fail when a protocol other than :puppet or :file is used" do
+            @request.stubs(:protocol).returns "http"
             proc { @object.select_terminus(@request) }.should raise_error(ArgumentError)
         end
-    end
-
-    describe "when looking for a module whose name matches the mount name" do
-        before do
-            @modules = mock 'modules'
-            @object.stubs(:terminus).with(:modules).returns(@modules)
-
-            @request.stubs(:key).returns "puppetmounts://host/mymod/file"
-        end
-
-        it "should use the modules terminus to look up the module" do
-            @modules.expects(:find_module).with("mymod", @request.options[:node])
-            @object.select_terminus @request
-        end
-
-        it "should pass the node name to the modules terminus" do
-            @modules.expects(:find_module).with("mymod", @request.options[:node])
-            @object.select_terminus @request
-        end
 
-        it "should log a deprecation warning if a module is found" do
-            @modules.expects(:find_module).with("mymod", @request.options[:node]).returns(:something)
-            Puppet.expects(:warning)
-            @object.select_terminus @request
+        describe "and the protocol is 'puppet'" do
+            before do
+                @request.stubs(:protocol).returns "puppet"
+            end
+
+            it "should choose :rest when a server is specified" do
+                @request.stubs(:protocol).returns "puppet"
+                @request.expects(:server).returns "foo"
+                @object.select_terminus(@request).should == :rest
+            end
+
+            # This is so a given file location works when bootstrapping with no server.
+            it "should choose :rest when the Settings name isn't 'puppet'" do
+                @request.stubs(:protocol).returns "puppet"
+                @request.stubs(:server).returns "foo"
+                Puppet.settings.stubs(:value).with(:name).returns "foo"
+                @object.select_terminus(@request).should == :rest
+            end
+
+            it "should choose :file_server when the settings name is 'puppet' and no server is specified" do
+                modules = mock 'modules'
+
+                @request.expects(:protocol).returns "puppet"
+                @request.expects(:server).returns nil
+                Puppet.settings.expects(:value).with(:name).returns "puppet"
+                @object.select_terminus(@request).should == :file_server
+            end
         end
     end
 end