puppet 0.24.6 → 0.24.7

data/spec/integration/network/server/mongrel.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/server'
+require 'socket'
+
+describe Puppet::Network::Server do
+    describe "when using mongrel" do
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+        
+        before :each do
+            Puppet[:servertype] = 'mongrel'
+            @params = { :address => "127.0.0.1", :port => 34346, :handlers => [ :node ] }
+            @server = Puppet::Network::Server.new(@params)            
+        end
+
+        describe "before listening" do
+            it "should not be reachable at the specified address and port" do
+                lambda { TCPSocket.new('127.0.0.1', 34346) }.should raise_error(Errno::ECONNREFUSED)
+            end
+        end
+
+        describe "when listening" do
+            it "should be reachable on the specified address and port" do
+                @server.listen
+                lambda { TCPSocket.new('127.0.0.1', 34346) }.should_not raise_error            
+            end
+
+            it "should not allow multiple servers to listen on the same address and port" do
+                @server.listen
+                @server2 = Puppet::Network::Server.new(@params)
+                lambda { @server2.listen }.should raise_error
+            end
+        end
+        
+        describe "after unlistening" do
+            it "should not be reachable on the port and address assigned" do
+                @server.listen
+                @server.unlisten
+                lambda { TCPSocket.new('127.0.0.1', 34346) }.should raise_error(Errno::ECONNREFUSED)                
+            end
+        end
+            
+        after :each do
+            @server.unlisten if @server.listening?
+        end    
+    end
+end

data/spec/integration/network/server/webrick.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/network/server'
+require 'socket'
+
+describe Puppet::Network::Server do
+    describe "when using webrick" do
+        before :each do
+            Puppet[:servertype] = 'webrick'
+            @params = { :address => "127.0.0.1", :port => 34343, :handlers => [ :node ] }
+        end
+        
+        describe "before listening" do
+            it "should not be reachable at the specified address and port" do
+                lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error
+            end
+        end
+        
+        describe "when listening" do
+            it "should be reachable on the specified address and port" do
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))            
+                @server.listen
+                lambda { TCPSocket.new('127.0.0.1', 34343) }.should_not raise_error            
+            end
+                        
+            it "should not allow multiple servers to listen on the same address and port" do
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))            
+                @server.listen
+                @server2 = Puppet::Network::Server.new(@params.merge(:port => 34343))
+                lambda { @server2.listen }.should raise_error
+            end
+            
+            after :each do
+                @server.unlisten if @server.listening?
+            end
+        end
+        
+        describe "after unlistening" do
+            it "should not be reachable on the port and address assigned" do
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))            
+                @server.listen
+                @server.unlisten
+                lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error(Errno::ECONNREFUSED)                
+            end
+        end
+    end
+end

data/spec/integration/node.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-23.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/node'
+
+describe Puppet::Node do
+    describe "when delegating indirection calls" do
+        before do
+            @name = "me"
+            @node = Puppet::Node.new(@name)
+        end
+
+        it "should be able to use the exec terminus" do
+            Puppet::Node.indirection.stubs(:terminus_class).returns :exec
+
+            # Load now so we can stub
+            terminus = Puppet::Node.indirection.terminus(:exec)
+
+            terminus.expects(:query).with(@name).returns "myresults"
+            terminus.expects(:translate).with(@name, "myresults").returns "translated_results"
+            terminus.expects(:create_node).with(@name, "translated_results").returns @node
+
+            Puppet::Node.find(@name).should equal(@node)
+        end
+
+        it "should be able to use the yaml terminus" do
+            Puppet::Node.indirection.stubs(:terminus_class).returns :yaml
+
+            # Load now, before we stub the exists? method.
+            terminus = Puppet::Node.indirection.terminus(:yaml)
+
+            terminus.expects(:path).with(@name).returns "/my/yaml/file"
+
+            FileTest.expects(:exist?).with("/my/yaml/file").returns false
+            Puppet::Node.find(@name).should be_nil
+        end
+
+        it "should have an ldap terminus" do
+            Puppet::Node.indirection.terminus(:ldap).should_not be_nil
+        end
+
+        it "should be able to use the plain terminus" do
+            Puppet::Node.indirection.stubs(:terminus_class).returns :plain
+
+            # Load now, before we stub the exists? method.
+            Puppet::Node.indirection.terminus(:plain)
+
+            Puppet::Node.expects(:new).with(@name).returns @node
+
+            Puppet::Node.find(@name).should equal(@node)
+        end
+
+        describe "and using the memory terminus" do
+            before do
+                @name = "me"
+                @old_terminus = Puppet::Node.indirection.terminus_class
+                @terminus = Puppet::Node.indirection.terminus(:memory)
+                Puppet::Node.indirection.stubs(:terminus).returns @terminus
+                @node = Puppet::Node.new(@name)
+            end
+
+            it "should find no nodes by default" do
+                Puppet::Node.find(@name).should be_nil
+            end
+
+            it "should be able to find nodes that were previously saved" do
+                @node.save
+                Puppet::Node.find(@name).should equal(@node)
+            end
+
+            it "should replace existing saved nodes when a new node with the same name is saved" do
+                @node.save
+                two = Puppet::Node.new(@name)
+                two.save
+                Puppet::Node.find(@name).should equal(two)
+            end
+
+            it "should be able to remove previously saved nodes" do
+                @node.save
+                Puppet::Node.destroy(@node.name)
+                Puppet::Node.find(@name).should be_nil
+            end
+
+            it "should fail when asked to destroy a node that does not exist" do
+                proc { Puppet::Node.destroy(@node) }.should raise_error(ArgumentError)
+            end
+        end
+    end
+end

data/spec/integration/node/catalog.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-4-8.
+#  Copyright (c) 2008. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Node::Catalog do
+    describe "when using the indirector" do
+        before do
+            # This is so the tests work w/out networking.
+            Facter.stubs(:to_hash).returns({"hostname" => "foo.domain.com"})
+            Facter.stubs(:value).returns("eh")
+        end
+
+        after { Puppet::Node::Catalog.indirection.clear_cache }
+
+        it "should be able to delegate to the :yaml terminus" do
+            Puppet::Node::Catalog.indirection.stubs(:terminus_class).returns :yaml
+
+            # Load now, before we stub the exists? method.
+            terminus = Puppet::Node::Catalog.indirection.terminus(:yaml)
+            terminus.expects(:path).with("me").returns "/my/yaml/file"
+
+            FileTest.expects(:exist?).with("/my/yaml/file").returns false
+            Puppet::Node::Catalog.find("me").should be_nil
+        end
+
+        it "should be able to delegate to the :compiler terminus" do
+            Puppet::Node::Catalog.indirection.stubs(:terminus_class).returns :compiler
+
+            # Load now, before we stub the exists? method.
+            compiler = Puppet::Node::Catalog.indirection.terminus(:compiler)
+
+            node = mock 'node'
+            node.stub_everything
+
+            Puppet::Node.expects(:find).returns(node)
+            compiler.expects(:compile).with(node).returns nil
+
+            Puppet::Node::Catalog.find("me").should be_nil
+        end
+
+        it "should pass provided node information directly to the terminus" do
+            terminus = mock 'terminus'
+
+            Puppet::Node::Catalog.indirection.stubs(:terminus).returns terminus
+
+            node = mock 'node'
+            terminus.expects(:find).with { |request| request.options[:use_node] == node }
+            Puppet::Node::Catalog.find("me", :use_node => node)
+        end
+    end
+end

data/spec/integration/node/facts.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-4-8.
+#  Copyright (c) 2008. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Node::Facts do
+    describe "when using the indirector" do
+        after { Puppet::Node::Facts.indirection.clear_cache }
+
+        it "should expire any cached node instances when it is saved" do
+            Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
+            terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
+
+            terminus.expects(:save)
+            Puppet::Node.expects(:expire).with("me")
+
+            facts = Puppet::Node::Facts.new("me")
+            facts.save
+        end
+
+        it "should be able to delegate to the :yaml terminus" do
+            Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
+
+            # Load now, before we stub the exists? method.
+            terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
+
+            terminus.expects(:path).with("me").returns "/my/yaml/file"
+            FileTest.expects(:exist?).with("/my/yaml/file").returns false
+
+            Puppet::Node::Facts.find("me").should be_nil
+        end
+
+        it "should be able to delegate to the :facter terminus" do
+            Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :facter
+
+            Facter.expects(:to_hash).returns "facter_hash"
+            facts = Puppet::Node::Facts.new("me")
+            Puppet::Node::Facts.expects(:new).with("me", "facter_hash").returns facts
+
+            Puppet::Node::Facts.find("me").should equal(facts)
+        end
+    end
+end

data/spec/integration/provider/package.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+describe "Package Provider" do
+    Puppet::Type.type(:package).providers.each do |name|
+        provider = Puppet::Type.type(:package).provider(name)
+
+        describe name do
+            confine "Provider %s is not suitable" % name => provider.suitable?
+
+            it "should fail when asked to install an invalid package" do
+                pending("This test hangs forever with recent versions of RubyGems") if provider.name == :gem
+                pkg = Puppet::Type.newpackage :name => "nosuch%s" % provider.name.to_s, :provider => provider.name
+                lambda { pkg.provider.install }.should raise_error
+            end
+
+            it "should be able to get a list of existing packages" do
+                provider.instances.each do |package|
+                    package.should be_instance_of(provider)
+                    package.properties[:provider].should == provider.name
+                end
+            end
+        end
+    end
+end

data/spec/integration/provider/service/init.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+# Find and load the spec file.
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+provider = Puppet::Type.type(:service).provider(:init)
+
+describe provider do
+    describe "when running on FreeBSD" do
+        confine "Not running on FreeBSD" => (Facter.value(:operatingsystem) == "FreeBSD")
+
+        it "should set its default path to include /etc/init.d and /usr/local/etc/init.d" do
+            provider.defpath.should == ["/etc/rc.d", "/usr/local/etc/rc.d"]
+        end
+    end
+
+    describe "when running on HP-UX" do
+        confine "Not running on HP-UX" => (Facter.value(:operatingsystem) == "HP-UX")
+
+        it "should set its default path to include /sbin/init.d" do
+            provider.defpath.should == "/sbin/init.d"
+        end
+    end
+
+    describe "when not running on FreeBSD or HP-UX" do
+        confine "Running on HP-UX or FreeBSD" => (! %w{HP-UX FreeBSD}.include?(Facter.value(:operatingsystem)))
+
+        it "should set its default path to include /etc/init.d" do
+            provider.defpath.should == "/etc/init.d"
+        end
+    end
+end

data/spec/integration/reference/providers.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/util/reference'
+
+reference = Puppet::Util::Reference.reference(:providers)
+
+describe reference do
+    it "should exist" do
+        reference.should_not be_nil
+    end
+
+    it "should be able to be rendered as text" do
+        lambda { reference.to_text }.should_not raise_error
+    end
+end

data/spec/integration/reports.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-12.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/reports'
+
+describe Puppet::Reports, " when using report types" do
+    it "should load report types as modules" do
+        Puppet::Reports.report(:store).should be_instance_of(Module)
+    end
+end

data/spec/integration/transaction/report.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-4-8.
+#  Copyright (c) 2008. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Transaction::Report do
+    describe "when using the indirector" do
+        after { Puppet::Transaction::Report.indirection.clear_cache }
+
+        it "should be able to delegate to the :processor terminus" do
+            Puppet::Transaction::Report.indirection.stubs(:terminus_class).returns :processor
+
+            terminus = Puppet::Transaction::Report.indirection.terminus(:processor)
+
+            Facter.stubs(:value).returns "host.domain.com"
+
+            report = Puppet::Transaction::Report.new
+
+            terminus.expects(:process).with(report)
+
+            report.save
+        end
+    end
+end

data/spec/integration/type/package.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:package), "when choosing a default package provider" do
+    before do
+        # the default provider is cached.
+        Puppet::Type.type(:package).defaultprovider = nil
+    end
+
+    def provider_name(os)
+        {"Debian" => :apt, "Darwin" => :apple, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
+    end
+
+    it "should have a default provider" do
+        Puppet::Type.type(:package).defaultprovider.should_not be_nil
+    end
+
+    it "should choose the correct provider each platform" do
+        Puppet::Type.type(:package).defaultprovider.name.should == provider_name(Facter.value(:operatingsystem))
+    end
+end

data/spec/integration/util/file_locking.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+require 'puppet/util/file_locking'
+
+describe Puppet::Util::FileLocking do
+    it "should be able to keep file corruption from happening when there are multiple writers" do
+        file = Tempfile.new("puppetspec")
+        file.close!()
+        file = file.path
+        data = {:a => :b, :c => "A string", :d => "another string", :e => %w{an array of strings}}
+        File.open(file, "w") { |f| f.puts YAML.dump(data) }
+
+        threads = []
+        sync = Sync.new
+        9.times { |a|
+            threads << Thread.new {
+                9.times { |b|
+                    sync.synchronize(Sync::SH) {
+                        Puppet::Util::FileLocking.readlock(file) { |f|
+                            YAML.load(f.read).should == data
+                        }
+                    }
+                    sleep 0.01
+                    sync.synchronize(Sync::EX) {
+                        Puppet::Util::FileLocking.writelock(file) { |f|
+                            f.puts YAML.dump(data)
+                        }
+                    }
+                }
+            }
+        }
+        threads.each { |th| th.join }
+    end
+end