puppet 0.25.1 → 0.25.2

data/spec/unit/application/puppetd.rb

@@ -173,6 +173,7 @@ describe "puppetd" do
             Puppet.stubs(:info)
             FileTest.stubs(:exists?).returns(true)
             Puppet.stubs(:[])
+            Puppet.stubs(:[]).with(:libdir).returns("/dev/null/lib")
             Puppet.settings.stubs(:print_config?)
             Puppet.settings.stubs(:print_config)
             Puppet::SSL::Host.stubs(:ca_location=)

data/spec/unit/application/puppetdoc.rb

@@ -290,16 +290,16 @@ describe "puppetdoc" do
                 @puppetdoc.manifest = false
                 Puppet.stubs(:info)
                 Puppet.stubs(:[]).with(:trace).returns(false)
-                Puppet.stubs(:[]).with(:modulepath).returns('modules')
-                Puppet.stubs(:[]).with(:manifestdir).returns('manifests')
+                @env = stub 'env'
+                Puppet::Node::Environment.stubs(:new).returns(@env)
+                @env.stubs(:modulepath).returns(['modules'])
+                @env.stubs(:[]).with(:manifest).returns('manifests/site.pp')
                 @puppetdoc.options.stubs(:[]).with(:all).returns(false)
                 @puppetdoc.options.stubs(:[]).with(:outputdir).returns('doc')
                 Puppet.settings.stubs(:[]=).with(:document_all, false)
                 Puppet.settings.stubs(:setdefaults)
                 Puppet::Util::RDoc.stubs(:rdoc)
                 @puppetdoc.stubs(:exit)
-                File.stubs(:expand_path).with('modules').returns('modules')
-                File.stubs(:expand_path).with('manifests').returns('manifests')
                 @old = ARGV.dup
                 ARGV.clear
             end
@@ -331,6 +331,15 @@ describe "puppetdoc" do
                 Puppet::Util::RDoc.expects(:manifestdoc)
                 @puppetdoc.rdoc
             end
+
+            it "should get modulepath and manifestdir values from the environment" do
+                @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
+                @env.expects(:[]).with(:manifest).returns('envmanifests/site.pp')
+
+                Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'])
+
+                @puppetdoc.rdoc
+            end
         end
 
         describe "in the other modes" do

data/spec/unit/application/puppetmasterd.rb

@@ -237,6 +237,7 @@ describe "PuppetMaster" do
 
         it "should dispatch to parseonly if parseonly is set" do
             Puppet.stubs(:[]).with(:parseonly).returns(true)
+            @puppetmasterd.options[:node] = nil
 
             @puppetmasterd.get_command.should == :parseonly
         end

data/spec/unit/application/puppetrun.rb

@@ -144,11 +144,21 @@ describe "puppetrun" do
                 Puppet.stubs(:[]).with(:node_terminus).returns("ldap")
             end
 
+            it "should pass the fqdn option to search" do
+                @puppetrun.options.stubs(:[]).with(:fqdn).returns(:something)
+                @puppetrun.options.stubs(:[]).with(:all).returns(true)
+                @puppetrun.stubs(:puts)
+
+                Puppet::Node.expects(:search).with("whatever",:fqdn => :something).returns([])
+
+                @puppetrun.run_setup
+            end
+
             it "should search for all nodes if --all" do
                 @puppetrun.options.stubs(:[]).with(:all).returns(true)
                 @puppetrun.stubs(:puts)
 
-                Puppet::Node.expects(:search).with("whatever").returns([])
+                Puppet::Node.expects(:search).with("whatever",:fqdn => nil).returns([])
 
                 @puppetrun.run_setup
             end
@@ -158,7 +168,7 @@ describe "puppetrun" do
                 @puppetrun.stubs(:puts)
                 @puppetrun.classes = ['class']
 
-                Puppet::Node.expects(:search).with("whatever", :class => "class").returns([])
+                Puppet::Node.expects(:search).with("whatever", :class => "class", :fqdn => nil).returns([])
 
                 @puppetrun.run_setup
             end

data/spec/unit/application/ralsh.rb

@@ -132,17 +132,34 @@ describe "ralsh" do
 
     describe "when running" do
 
+        def set_args(args)
+            (ARGV.clear << args).flatten!
+        end
+
+        def push_args(*args)
+            @args_stack ||= []
+            @args_stack << ARGV.dup
+            set_args(args)
+        end
+
+        def pop_args
+            set_args(@args_stack.pop)
+        end
+
         before :each do
             @type = stub_everything 'type', :properties => []
-            ARGV.stubs(:shift).returns("type")
-            ARGV.stubs(:length).returns(1).then.returns(0)
+            push_args('type')
             Puppet::Type.stubs(:type).returns(@type)
         end
 
-        it "should raise an error if no type is given" do
-            ARGV.stubs(:length).returns(0)
+        after :each do
+            pop_args
+        end
 
+        it "should raise an error if no type is given" do
+            push_args
             lambda { @ralsh.main }.should raise_error
+            pop_args
         end
 
         it "should raise an error when editing a remote host" do
@@ -186,11 +203,10 @@ describe "ralsh" do
             end
 
             it "should describe the given resource" do
-                ARGV.stubs(:shift).returns("type").then.returns('name')
-                ARGV.stubs(:length).returns(1).then.returns(1).then.returns(0)
+                push_args('type','name')
                 @client.expects(:describe).returns(stub_everything)
-
                 @ralsh.main
+                pop_args
             end
         end
 
@@ -208,30 +224,31 @@ describe "ralsh" do
 
             describe 'but with a given name' do
                 before :each do
-                    ARGV.stubs(:shift).returns("type").then.returns('name')
-                    ARGV.stubs(:length).returns(1).then.returns(1).then.returns(0)
-                    @object = stub_everything 'object', :to_trans => stub_everything('transportable')
-                    @type.stubs(:new).returns(@object)
-                    @object.stubs(:retrieve)
+                    push_args('type','name')
+                    @type.stubs(:new).returns(:bob)
                 end
 
-                it "should retrieve a specific instance" do
-                    @type.expects(:new).returns(@object)
-                    @object.expects(:retrieve)
+                after :each do
+                    pop_args
+                end
 
-                    @ralsh.main
+                it "should retrieve a specific instance if it exists" do
+                    pending
                 end
 
-                it "should add given parameters to object" do
-                    ARGV.stubs(:each).yields('param=temp')
-                    ARGV.stubs(:length).returns(1).then.returns(1).then.returns(1)
-                    Puppet::Resource::Catalog.stubs(:new).returns(stub_everything)
-                    @object.expects(:[]=).with('param','temp')
 
+                it "should create a stub instance if it doesn't exist" do
+                    pending
+                end
+
+                it "should add given parameters to the object" do
+                    push_args('type','name','param=temp')
+                    pending
+                    @object.expects(:[]=).with('param','temp')
                     @ralsh.main
+                    pop_args
                 end
             end
         end
-
     end
 end

data/spec/unit/configurer.rb

@@ -183,6 +183,12 @@ describe Puppet::Configurer, "when converting the catalog" do
         @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
     end
 
+    it "should finalize the catalog" do
+        @catalog.expects(:finalize)
+
+        @agent.convert_catalog(@oldcatalog, 10)
+    end
+
     it "should record the passed retrieval time with the RAL catalog" do
         @catalog.expects(:retrieval_duration=).with 10
 

data/spec/unit/configurer/fact_handler.rb

@@ -97,6 +97,7 @@ describe Puppet::Configurer::FactHandler do
     # I couldn't get marshal to work for this, only yaml, so we hard-code yaml.
     it "should serialize and CGI escape the fact values for uploading" do
         facts = stub 'facts'
+        facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
         facts.expects(:render).returns "my text"
         text = CGI.escape("my text")
 
@@ -107,6 +108,7 @@ describe Puppet::Configurer::FactHandler do
 
     it "should properly accept facts containing a '+'" do
         facts = stub 'facts'
+        facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
         facts.expects(:render).returns "my+text"
         text = "my%2Btext"
 
@@ -115,8 +117,9 @@ describe Puppet::Configurer::FactHandler do
         @facthandler.facts_for_uploading.should == {:facts_format => :b64_zlib_yaml, :facts => text}
     end
 
-    it "should hard-code yaml as the serialization" do
+    it "use compressed yaml as the serialization if zlib is supported" do
         facts = stub 'facts'
+        facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
         facts.expects(:render).with(:b64_zlib_yaml).returns "my text"
         text = CGI.escape("my text")
 
@@ -125,6 +128,17 @@ describe Puppet::Configurer::FactHandler do
         @facthandler.facts_for_uploading
     end
 
+    it "should use yaml as the serialization if zlib is not supported" do
+        facts = stub 'facts'
+        facts.expects(:support_format?).with(:b64_zlib_yaml).returns false
+        facts.expects(:render).with(:yaml).returns "my text"
+        text = CGI.escape("my text")
+
+        @facthandler.expects(:find_facts).returns facts
+
+        @facthandler.facts_for_uploading
+    end
+
     describe "when reloading Facter" do
         before do
             Facter.stubs(:clear)

data/spec/unit/file_serving/metadata.rb

@@ -20,6 +20,84 @@ describe Puppet::FileServing::Metadata do
     it "should have a method that triggers attribute collection" do
         Puppet::FileServing::Metadata.new("/foo/bar").should respond_to(:collect)
     end
+
+    it "should support pson serialization" do
+        Puppet::FileServing::Metadata.new("/foo/bar").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) 
+    end
+
+    it "should support pson deserialization" do
+        Puppet::FileServing::Metadata.should respond_to(:from_pson) 
+    end
+
+    describe "when serializing" do
+        before do
+            @metadata = Puppet::FileServing::Metadata.new("/foo/bar")
+        end
+        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
+            pdh.expects(:to_pson).returns 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"
+        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
+        end
+
+        it "should pass the path in the hash verbatum" do
+            @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
+        end
+
+        it "should pass the links in the hash verbatum" do
+            @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
+        end
+
+        it "should pass the group in the hash verbatum" do
+            @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
+        end
+
+        it "should pass the ftype in the hash verbatum as the 'type'" do
+            @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
+        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)
+        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
+        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
+        end
+
+    end
 end
 
 describe Puppet::FileServing::Metadata, " when finding the file to use for setting attributes" do
@@ -29,6 +107,10 @@ describe Puppet::FileServing::Metadata, " when finding the file to use for setti
 
         # Use a link because it's easier to test -- no checksumming
         @stat = stub "stat", :uid => 10, :gid => 20, :mode => 0755, :ftype => "link"
+
+        # Not quite.  We don't want to checksum links, but we must because they might be being followed.
+        @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+        @metadata.stubs(:md5_file).returns(@checksum)           #
     end
 
     it "should accept a base path path to which the file should be relative" do
@@ -139,6 +221,9 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
             @stat.stubs(:ftype).returns("link")
             File.expects(:readlink).with("/my/file").returns("/path/to/link")
             @metadata.collect
+ 
+            @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+            @file.stubs(:md5_file).returns(@checksum)           #
         end
 
         it "should read links instead of returning their checksums" do
@@ -146,29 +231,56 @@ describe Puppet::FileServing::Metadata, " when collecting attributes" do
         end
 
         it "should produce tab-separated mode, type, owner, group, and destination for xmlrpc" do
-            @metadata.attributes_with_tabs.should == "#{0755.to_s}\tlink\t10\t20\t/path/to/link"
+            pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+            @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t/path/to/link"
+        end
+
+        it "should produce tab-separated mode, type, owner, group, checksum, and destination for xmlrpc" do
+            @metadata.attributes_with_tabs.should == "#{0755}\tlink\t10\t20\t{md5}eb9c2bf0eb63f3a7bc0ea37ef18aeba5\t/path/to/link"
         end
     end
 end
 
 describe Puppet::FileServing::Metadata, " when pointing to a link" do
-    it "should store the destination of the link in :destination if links are :manage" do
-        file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
-
-        File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-        File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
+    describe "when links are managed" do
+        before do
+            @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
+            File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+            File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
 
-        file.collect
-        file.destination.should == "/some/other/path"
+            @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
+            @file.stubs(:md5_file).returns(@checksum)           #
+        end
+        it "should store the destination of the link in :destination if links are :manage" do
+            @file.collect
+            @file.destination.should == "/some/other/path"
+        end
+        it "should not collect the checksum if links are :manage" do
+            pending "We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow."
+            @file.collect
+            @file.checksum.should be_nil
+        end
+        it "should collect the checksum if links are :manage" do # see pending note above
+            @file.collect
+            @file.checksum.should == "{md5}#{@checksum}"
+        end
     end
 
-    it "should not collect the checksum" do
-        file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :manage)
-
-        File.expects(:lstat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-        File.expects(:readlink).with("/base/path/my/file").returns "/some/other/path"
-
-        file.collect
-        file.checksum.should be_nil
+    describe "when links are followed" do
+        before do
+            @file = Puppet::FileServing::Metadata.new("/base/path/my/file", :links => :follow)
+            File.expects(:stat).with("/base/path/my/file").returns stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
+            File.expects(:readlink).with("/base/path/my/file").never
+            @checksum = Digest::MD5.hexdigest("some content\n")
+            @file.stubs(:md5_file).returns(@checksum)
+        end
+        it "should not store the destination of the link in :destination if links are :follow" do
+            @file.collect
+            @file.destination.should be_nil
+        end
+        it "should collect the checksum if links are :follow" do
+            @file.collect
+            @file.checksum.should == "{md5}#{@checksum}"
+        end
     end
 end

data/spec/unit/file_serving/mount/file.rb

@@ -107,6 +107,14 @@ describe Puppet::FileServing::Mount::File, "when determining the complete file p
         @mount.complete_path("/my/path", nil).should be_nil
     end
 
+    it "should write a log message if the file is absent" do
+        FileTest.stubs(:exist?).returns(false)
+
+        Puppet.expects(:info).with("File does not exist or is not accessible: /mount/my/path")
+
+        @mount.complete_path("/my/path", nil)
+    end
+
     it "should return the file path if the file is present" do
         FileTest.stubs(:exist?).with("/my/path").returns(true)
         @mount.complete_path("/my/path", nil).should == "/mount/my/path"

data/spec/unit/indirector/catalog/active_record.rb

@@ -76,9 +76,12 @@ describe "Puppet::Resource::Catalog::ActiveRecord" do
 
     describe "when saving an instance" do
         before do
-            @host = stub 'host', :name => "foo", :save => nil, :merge_resources => nil, :last_compile= => nil
+            @host = stub 'host', :name => "foo", :save => nil, :merge_resources => nil, :last_compile= => nil, :ip= => nil, :environment= => nil
             @host.stubs(:railsmark).yields
 
+            @node = stub_everything 'node', :parameters => {}
+            Puppet::Node.stubs(:find).returns(@node)
+
             Puppet::Rails::Host.stubs(:find_by_name).returns @host
             @catalog = Puppet::Resource::Catalog.new("foo")
             @request = stub 'request', :key => "foo", :instance => @catalog
@@ -105,6 +108,22 @@ describe "Puppet::Resource::Catalog::ActiveRecord" do
             @terminus.save(@request)
         end
 
+        it "should set host ip if we could find a matching node" do
+            @node.stubs(:parameters).returns({"ipaddress" => "192.168.0.1"})
+
+            @host.expects(:ip=).with '192.168.0.1'
+
+            @terminus.save(@request)
+        end
+
+        it "should set host environment if we could find a matching node" do
+            @node.stubs(:environment).returns("myenv")
+
+            @host.expects(:environment=).with 'myenv'
+
+            @terminus.save(@request)
+        end
+
         it "should set the last compile time on the host" do
             now = Time.now
             Time.expects(:now).returns now