puppet 0.24.9 → 0.25.0

data/spec/integration/network/client.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/client'
+
+describe Puppet::Network::Client do
+    %w{ca dipper file report resource runner status}.each do |name|
+        it "should have a #{name} client" do
+            Puppet::Network::Client.client(name).should be_instance_of(Class)
+        end
+
+        [:name, :handler, :drivername].each do |data|
+            it "should have a #{data} value for the #{name} client" do
+                Puppet::Network::Client.client(name).send(data).should_not be_nil
+            end
+        end
+    end
+end

data/spec/integration/network/formats.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/formats'
+
+class JsonIntTest
+    attr_accessor :string
+    def ==(other)
+        other.class == self.class and string == other.string
+    end
+
+    def self.from_json(data)
+        new(data[0])
+    end
+
+    def initialize(string)
+        @string = string
+    end
+
+    def to_json(*args)
+        {
+            'json_class' => self.class.name,
+            'data' => [@string]
+        }.to_json(*args)
+    end
+
+    def self.canonical_order(s)
+        s.gsub(/\{"data":\[(.*?)\],"json_class":"JsonIntTest"\}/,'{"json_class":"JsonIntTest","data":[\1]}')
+    end
+
+end
+
+describe Puppet::Network::FormatHandler.format(:s) do
+    before do
+        @format = Puppet::Network::FormatHandler.format(:s)
+    end
+
+    it "should support certificates" do
+        @format.should be_supported(Puppet::SSL::Certificate)
+    end
+
+    it "should not support catalogs" do
+        @format.should_not be_supported(Puppet::Resource::Catalog)
+    end
+end
+
+describe Puppet::Network::FormatHandler.format(:json) do
+    describe "when json is absent" do
+        confine "'json' library is present" => (! Puppet.features.json?)
+
+        before do
+            @json = Puppet::Network::FormatHandler.format(:json)
+        end
+
+        it "should not be suitable" do
+            @json.should_not be_suitable
+        end
+    end
+
+    describe "when json is available" do
+        confine "Missing 'json' library" => Puppet.features.json?
+
+        before do
+            @json = Puppet::Network::FormatHandler.format(:json)
+        end
+
+        it "should be able to render an instance to json" do
+            instance = JsonIntTest.new("foo")
+            JsonIntTest.canonical_order(@json.render(instance)).should == JsonIntTest.canonical_order('{"json_class":"JsonIntTest","data":["foo"]}' )
+        end
+
+        it "should be able to render arrays to json" do
+            @json.render([1,2]).should == '[1,2]'
+        end
+
+        it "should be able to render arrays containing hashes to json" do
+            @json.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
+        end
+
+        it "should be able to render multiple instances to json" do
+            Puppet.features.add(:json, :libs => ["json"])
+
+            one = JsonIntTest.new("one")
+            two = JsonIntTest.new("two")
+
+            JsonIntTest.canonical_order(@json.render([one,two])).should == JsonIntTest.canonical_order('[{"json_class":"JsonIntTest","data":["one"]},{"json_class":"JsonIntTest","data":["two"]}]')
+        end
+
+        it "should be able to intern json into an instance" do
+            @json.intern(JsonIntTest, '{"json_class":"JsonIntTest","data":["foo"]}').should == JsonIntTest.new("foo")
+        end
+
+        it "should be able to intern json with no class information into an instance" do
+            @json.intern(JsonIntTest, '["foo"]').should == JsonIntTest.new("foo")
+        end
+
+        it "should be able to intern multiple instances from json" do
+            @json.intern_multiple(JsonIntTest, '[{"json_class": "JsonIntTest", "data": ["one"]},{"json_class": "JsonIntTest", "data": ["two"]}]').should == [
+                JsonIntTest.new("one"), JsonIntTest.new("two")
+            ]
+        end
+
+        it "should be able to intern multiple instances from json with no class information" do
+            @json.intern_multiple(JsonIntTest, '[["one"],["two"]]').should == [
+                JsonIntTest.new("one"), JsonIntTest.new("two")
+            ]
+        end
+    end
+end

data/spec/integration/network/handler.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/client'
+
+describe Puppet::Network::Handler do
+    %w{ca filebucket fileserver master report resource runner status}.each do |name|
+        it "should have a #{name} client" do
+            Puppet::Network::Handler.handler(name).should be_instance_of(Class)
+        end
+
+        it "should have a name" do
+            Puppet::Network::Handler.handler(name).name.to_s.downcase.should == name.to_s.downcase
+        end
+
+        it "should have an interface" do
+            Puppet::Network::Handler.handler(name).interface.should_not be_nil
+        end
+
+        it "should have a prefix for the interface" do
+            Puppet::Network::Handler.handler(name).interface.prefix.should_not be_nil
+        end
+    end
+end

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

@@ -7,13 +7,16 @@ 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)            
+            Puppet[:server] = '127.0.0.1'
+            @params = { :port => 34346, :handlers => [ :node ] }
+            @server = Puppet::Network::Server.new(@params)
         end
 
+        after { Puppet.settings.clear }
+
         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)
@@ -23,7 +26,22 @@ describe Puppet::Network::Server do
         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            
+                lambda { TCPSocket.new('127.0.0.1', 34346) }.should_not raise_error
+            end
+
+            it "should default to '127.0.0.1' as its bind address" do
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
+                @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
+                @server.send(:http_server).expects(:listen).with { |args| args[:address] == "127.0.0.1" }
+                @server.listen
+            end
+
+            it "should use any specified bind address" do
+                Puppet[:bindaddress] = "0.0.0.0"
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
+                @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
+                @server.send(:http_server).expects(:listen).with { |args| args[:address] == "0.0.0.0" }
+                @server.listen
             end
 
             it "should not allow multiple servers to listen on the same address and port" do
@@ -32,17 +50,17 @@ describe Puppet::Network::Server do
                 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)                
+                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
 end

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

@@ -2,46 +2,84 @@
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/network/server'
+require 'puppet/ssl/certificate_authority'
 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 ] }
+            Puppet[:server] = '127.0.0.1'
+            @params = { :port => 34343, :handlers => [ :node ], :xmlrpc_handlers => [ :status ] }
+
+            # Get a safe temporary file
+            @tmpfile = Tempfile.new("webrick_integration_testing")
+            @dir = @tmpfile.path + "_dir"
+
+            Puppet.settings[:confdir] = @dir
+            Puppet.settings[:vardir] = @dir
+
+            Puppet::SSL::Host.ca_location = :local
+
+            ca = Puppet::SSL::CertificateAuthority.new
+            ca.generate(Puppet[:certname]) unless Puppet::SSL::Certificate.find(Puppet[:certname])
+        end
+
+        after do
+            @tmpfile.delete
+            Puppet.settings.clear
+
+            system("rm -rf %s" % @dir)
+
+            Puppet::Util::Cacher.expire
         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 = Puppet::Network::Server.new(@params.merge(:port => 34343))
                 @server.listen
-                lambda { TCPSocket.new('127.0.0.1', 34343) }.should_not raise_error            
+                lambda { TCPSocket.new('127.0.0.1', 34343) }.should_not raise_error
             end
-                        
+
+            it "should default to '0.0.0.0' as its bind address" do
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
+                @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
+                @server.send(:http_server).expects(:listen).with { |args| args[:address] == "0.0.0.0" }
+                @server.listen
+            end
+
+            it "should use any specified bind address" do
+                Puppet[:bindaddress] = "127.0.0.1"
+                @server = Puppet::Network::Server.new(@params.merge(:port => 34343))
+                @server.stubs(:unlisten) # we're breaking listening internally, so we have to keep it from unlistening
+                @server.send(:http_server).expects(:listen).with { |args| args[:address] == "127.0.0.1" }
+                @server.listen
+            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 = 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 = 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)                
+                lambda { TCPSocket.new('127.0.0.1', 34343) }.should raise_error(Errno::ECONNREFUSED)
             end
         end
     end

data/spec/integration/node/environment.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet_spec/files'
+
+describe Puppet::Node::Environment do
+    include PuppetSpec::Files
+
+    it "should be able to return each module from its environment with the environment, name, and path set correctly" do
+        base = tmpfile("env_modules")
+        Dir.mkdir(base)
+
+        dirs = []
+        mods = {}
+        %w{1 2}.each do |num|
+            dir = File.join(base, "dir#{num}")
+            dirs << dir
+            Dir.mkdir(dir)
+            mod = "mod#{num}"
+            moddir = File.join(dir, mod)
+            mods[mod] = moddir
+            Dir.mkdir(moddir)
+        end
+
+        environment = Puppet::Node::Environment.new("foo")
+        environment.stubs(:modulepath).returns dirs
+
+        environment.modules.each do |mod|
+            mod.environment.should == environment
+            mod.path.should == mods[mod.name]
+        end
+    end
+
+    it "should not yield the same module from different module paths" do
+        base = tmpfile("env_modules")
+        Dir.mkdir(base)
+
+        dirs = []
+        mods = {}
+        %w{1 2}.each do |num|
+            dir = File.join(base, "dir#{num}")
+            dirs << dir
+            Dir.mkdir(dir)
+            mod = "mod"
+            moddir = File.join(dir, mod)
+            mods[mod] = moddir
+            Dir.mkdir(moddir)
+        end
+
+        environment = Puppet::Node::Environment.new("foo")
+        environment.stubs(:modulepath).returns dirs
+
+        mods = environment.modules
+        mods.length.should == 1
+        mods[0].path.should == File.join(base, "dir1", "mod")
+    end
+end

data/spec/integration/node/facts.rb

@@ -7,13 +7,15 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Node::Facts do
     describe "when using the indirector" do
-        after { Puppet::Node::Facts.indirection.clear_cache }
+        after { Puppet::Util::Cacher.expire }
 
         it "should expire any cached node instances when it is saved" do
             Puppet::Node::Facts.indirection.stubs(:terminus_class).returns :yaml
+
+            Puppet::Node::Facts.indirection.terminus(:yaml).should equal(Puppet::Node::Facts.indirection.terminus(:yaml))
             terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
+            terminus.stubs :save
 
-            terminus.expects(:save)
             Puppet::Node.expects(:expire).with("me")
 
             facts = Puppet::Node::Facts.new("me")

data/spec/integration/parser/compiler.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Parser::Compiler do
+    before :each do
+        @node = Puppet::Node.new "testnode"
+
+        @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
+        @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
+    end
+
+    after do
+        Puppet.settings.clear
+    end
+
+    it "should be able to determine the configuration version from a local version control repository" do
+        # This should always work, because we should always be
+        # in the puppet repo when we run this.
+        version = %x{git rev-parse HEAD}.chomp
+
+        Puppet.settings[:config_version] = 'git rev-parse HEAD'
+
+        @parser = Puppet::Parser::Parser.new :environment => "development"
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+
+        @compiler.catalog.version.should == version
+    end
+end

data/spec/integration/parser/functions/require.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "the require function" do
+
+    before :each do
+        @parser = Puppet::Parser::Parser.new :Code => ""
+        @node = Puppet::Node.new("mynode")
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+
+        @compiler.send(:evaluate_main)
+        @scope = @compiler.topscope
+        # preload our functions
+        Puppet::Parser::Functions.function(:include)
+        Puppet::Parser::Functions.function(:require)
+    end
+
+    it "should add a relationship between the 'required' class and our class" do
+        @parser.newclass("requiredclass")
+
+        @scope.function_require("requiredclass")
+
+        @compiler.catalog.edge?(@scope.resource,@compiler.findresource(:class,"requiredclass")).should be_true
+    end
+
+end
+
+describe "the include function" do
+    require 'puppet_spec/files'
+    include PuppetSpec::Files
+
+    before :each do
+        @real_dir = Dir.getwd
+        @temp_dir = tmpfile('include_function_integration_test')
+        Dir.mkdir @temp_dir
+        Dir.chdir @temp_dir
+        @parser = Puppet::Parser::Parser.new :Code => ""
+        @node = Puppet::Node.new("mynode")
+        @compiler = Puppet::Parser::Compiler.new(@node, @parser)
+        @compiler.send(:evaluate_main)
+        @scope = @compiler.topscope
+        # preload our functions
+        Puppet::Parser::Functions.function(:include)
+        Puppet::Parser::Functions.function(:require)
+    end
+
+    after :each do
+        Dir.chdir @real_dir
+        Dir.rmdir @temp_dir
+    end
+
+    def with_file(filename,contents)
+        path = File.join(@temp_dir,filename)
+        File.open(path, "w") { |f|f.puts contents }
+        yield
+        File.delete(path)
+    end
+
+    it "should add a relationship between the 'included' class and our class" do
+        with_file('includedclass',"class includedclass {}") {
+            @scope.function_include("includedclass")
+            }
+        @compiler.catalog.edge?(@scope.resource,@compiler.findresource(:class,"includedclass")).should be_true
+    end
+
+end