puppet 0.24.9 → 0.25.0

data/test/network/rights.rb

@@ -6,7 +6,7 @@ require 'puppettest'
 require 'puppet/network/rights'
 
 class TestRights < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super

data/test/network/server/mongrel_test.rb

@@ -29,7 +29,19 @@ class TestMongrelServer < PuppetTest::TestCase
         params[Puppet[:ssl_client_header]] = ""
         params[Puppet[:ssl_client_verify_header]] = "failure"
         info = nil
-        Resolv.expects(:getname).with(ip).returns("host.domain.com").times(3)
+        Resolv.expects(:getname).with(ip).returns("host.domain.com").times(4)
+        assert_nothing_raised("Could not call client_info") do
+            info = mongrel.send(:client_info, obj)
+        end
+        assert(! info.authenticated?, "Client info object was marked valid even though headers were missing")
+        assert_equal(ip, info.ip, "Did not copy over ip correctly")
+
+        assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
+
+        # Now pass the X-Forwarded-For header and check it is preferred over REMOTE_ADDR
+        params["REMOTE_ADDR"] = '127.0.0.1'
+        params["HTTP_X_FORWARDED_FOR"] = ip
+        info = nil
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
@@ -39,6 +51,8 @@ class TestMongrelServer < PuppetTest::TestCase
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
         # Now add a valid auth header.
+        params["REMOTE_ADDR"] = ip
+        params["HTTP_X_FORWARDED_FOR"] = nil
         params[Puppet[:ssl_client_header]] = "/CN=host.domain.com"
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)

data/test/network/server/webrick.rb

@@ -66,44 +66,8 @@ class TestWebrickServer < Test::Unit::TestCase
         assert_equal(1, retval)
     end
 
-    # Test that a client whose cert has been revoked really can't connect
-    def test_certificate_revocation
-        Puppet[:autosign] = true
-
-        serverpid, server = mk_status_server
-
-        client = mk_status_client
-
-        status = nil
-        assert_nothing_raised() {
-            status = client.status
-        }
-        assert_equal(1, status)
-        client.shutdown
-
-        # Revoke the client's cert
-        ca = Puppet::SSLCertificates::CA.new()
-        ca.revoke(ca.getclientcert(Puppet[:certname])[0].serial)
-
-        # Restart the server
-        @@port += 1
-        Puppet[:autosign] = false
-        kill_and_wait(serverpid, server.pidfile)
-        serverpid, server = mk_status_server
-
-        # This time the client should be denied.  With keep-alive,
-        # the client starts its connection immediately, thus throwing
-        # the error.
-        assert_raise(OpenSSL::SSL::SSLError) {
-            Puppet::Network::HttpPool.http_instance("localhost", @@port).start
-        }
-    end
-    
     def mk_status_client
         client = nil
-        # Otherwise, the client initalization will trip over itself
-        # since elements created in the last run are still around
-        Puppet::Type::allclear
 
         assert_nothing_raised() {
             client = Puppet::Network::Client.status.new(

data/test/network/xmlrpc/webrick_servlet.rb

@@ -10,11 +10,11 @@ require 'mocha'
 class TestXMLRPCWEBrickServlet < Test::Unit::TestCase
     include PuppetTest
     def test_basics
-	# Make sure we're doing things as our user info, rather than puppet/puppet
-	setme
-	set_mygroup
-	Puppet[:user] = @me
-	Puppet[:group] = @mygroup
+        # Make sure we're doing things as our user info, rather than puppet/puppet
+        setme
+        set_mygroup
+        Puppet[:user] = @me
+        Puppet[:group] = @mygroup
         servlet = nil
         ca = Puppet::Network::Handler.ca.new
 

data/test/other/dsl.rb

@@ -7,8 +7,8 @@ require 'puppet/dsl'
 require 'puppettest'
 
 class TestDSL < Test::Unit::TestCase
-	include PuppetTest
-	include Puppet::DSL
+    include PuppetTest
+    include Puppet::DSL
 
     def teardown
         super
@@ -75,7 +75,7 @@ class TestDSL < Test::Unit::TestCase
     def test_evaluate
         parent = child = nil
         parenteval = childeval = nil
-        
+
         assert_nothing_raised do
             parent = aspect :parent do
                 if parenteval

data/test/other/events.rb

@@ -7,19 +7,19 @@ require 'puppettest'
 
 
 class TestEvents < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def test_simplesubscribe
         name = tempfile()
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :name => name,
             :ensure => "file"
         )
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :name => "echo true",
             :path => "/usr/bin:/bin",
             :refreshonly => true,
-            :subscribe => [[file.class.name, file.name]] 
+            :subscribe => Puppet::Resource::Reference.new(file.class.name, file.name)
         )
 
         comp = mk_catalog("eventtesting", file, exec)
@@ -31,15 +31,15 @@ class TestEvents < Test::Unit::TestCase
 
     def test_simplerequire
         name = tempfile()
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :name => name,
             :ensure => "file"
         )
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :name => "echo true",
             :path => "/usr/bin:/bin",
             :refreshonly => true,
-            :require => [[file.class.name, file.name]] 
+            :require => Puppet::Resource::Reference.new(file.class.name, file.name)
         )
 
 
@@ -57,21 +57,21 @@ class TestEvents < Test::Unit::TestCase
         files = []
 
         4.times { |i|
-            files << Puppet.type(:file).create(
+            files << Puppet::Type.type(:file).new(
                 :name => tempfile(),
                 :ensure => "file"
             )
         }
 
         fname = tempfile()
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :refreshonly => true
         )
 
         exec[:subscribe] = files.collect { |f|
-            ["file", f.name]
+            Puppet::Resource::Reference.new(:file, f.name)
         }
 
         comp = mk_catalog(exec, *files)
@@ -84,13 +84,13 @@ class TestEvents < Test::Unit::TestCase
     def test_refreshordering
         file = tempfile()
 
-        exec1 = Puppet.type(:exec).create(
+        exec1 = Puppet::Type.type(:exec).new(
             :title => "one",
             :name => "echo one >> %s" % file,
             :path => "/usr/bin:/bin"
         )
 
-        exec2 = Puppet.type(:exec).create(
+        exec2 = Puppet::Type.type(:exec).new(
             :title => "two",
             :name => "echo two >> %s" % file,
             :path => "/usr/bin:/bin",
@@ -98,7 +98,7 @@ class TestEvents < Test::Unit::TestCase
             :subscribe => exec1
         )
 
-        exec3 = Puppet.type(:exec).create(
+        exec3 = Puppet::Type.type(:exec).new(
             :title => "three",
             :name => "echo three >> %s" % file,
             :path => "/usr/bin:/bin",
@@ -107,14 +107,14 @@ class TestEvents < Test::Unit::TestCase
         execs = [exec1, exec2, exec3]
 
         config = mk_catalog(exec1,exec2,exec3)
-        
+
         trans = Puppet::Transaction.new(config)
         execs.each do |e| assert(config.vertex?(e), "%s is not in graph" % e.title) end
         trans.prepare
         execs.each do |e| assert(config.vertex?(e), "%s is not in relgraph" % e.title) end
         reverse = trans.relationship_graph.reversal
         execs.each do |e| assert(reverse.vertex?(e), "%s is not in reversed graph" % e.title) end
-        
+
         config.apply
 
         assert(FileTest.exists?(file), "File does not exist")

data/test/other/puppet.rb

@@ -7,9 +7,9 @@ require 'puppettest'
 
 # Test the different features of the main puppet module
 class TestPuppetModule < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
     include SignalObserver
-    
+
     def mkfakeclient
         Class.new(Puppet::Network::Client) do
             def initialize
@@ -41,36 +41,6 @@ class TestPuppetModule < Test::Unit::TestCase
         end
     end
 
-    # Make sure that services get correctly started and stopped
-    def test_servicehandling
-        file = tempfile()
-        testclass = mktestclass()
-
-        obj = testclass.new(file)
-
-        assert_nothing_raised {
-            Puppet.newservice(obj)
-        }
-
-        assert_nothing_raised {
-            Puppet.start(false)
-        }
-
-        # Give it a sec or so
-        sleep 0.3
-
-        assert(obj.started?, "Object was not started")
-
-        assert_nothing_raised {
-            Puppet.shutdown(false)
-        }
-        # Give it a sec or so
-        sleep 0.3
-
-        assert(!obj.started?, "Object is still running")
-
-    end
-
     def test_path
         oldpath = ENV["PATH"]
         cleanup do

data/test/other/relationships.rb

@@ -6,21 +6,21 @@ require 'puppet'
 require 'puppettest'
 
 class TestRelationships < Test::Unit::TestCase
-	include PuppetTest
-	def setup
-	    super
-	    Puppet::Type.type(:exec)
+    include PuppetTest
+    def setup
+        super
+        Puppet::Type.type(:exec)
     end
-    
+
     def newfile
         assert_nothing_raised() {
-            return Puppet.type(:file).create(
+            return Puppet::Type.type(:file).new(
                 :path => tempfile,
                 :check => [:mode, :owner, :group]
             )
         }
     end
-    
+
     def check_relationship(sources, targets, out, refresher)
         if out
             deps = sources.builddepends
@@ -31,17 +31,17 @@ class TestRelationships < Test::Unit::TestCase
         end
         assert_instance_of(Array, deps)
         assert(! deps.empty?, "Did not receive any relationships")
-        
+
         deps.each do |edge|
             assert_instance_of(Puppet::Relationship, edge)
         end
-        
+
         sources.each do |source|
             targets.each do |target|
                 edge = deps.find { |e| e.source == source and e.target == target }
                 assert(edge, "Could not find edge for %s => %s" %
                     [source.ref, target.ref])
-        
+
                 if refresher
                     assert_equal(:ALL_EVENTS, edge.event)
                     assert_equal(:refresh, edge.callback)
@@ -53,119 +53,16 @@ class TestRelationships < Test::Unit::TestCase
         end
     end
 
-    # Make sure our various metaparams work correctly.  We're just checking
-    # here whether they correctly set up the callbacks and the direction of
-    # the relationship.
-    def test_relationship_metaparams
-        out = {:require => false, :subscribe => false,
-            :notify => true, :before => true}
-        refreshers = [:subscribe, :notify]
-        [:require, :subscribe, :notify, :before].each do |param|
-            # Create three files to generate our events and three
-            # execs to receive them
-            files = []
-            execs = []
-            3.times do |i|
-                files << Puppet::Type.newfile(
-                    :title => "file#{i}",
-                    :path => tempfile(),
-                    :ensure => :file
-                )
-
-                path = tempfile()
-                execs << Puppet::Type.newexec(
-                    :title => "notifytest#{i}",
-                    :path => "/usr/bin:/bin",
-                    :command => "touch #{path}",
-                    :refreshonly => true
-                )
-            end
-
-            # Add our first relationship
-            if out[param]
-                files[0][param] = execs[0]
-                sources = files[0]
-                targets = [execs[0]]
-            else
-                execs[0][param] = files[0]
-                sources = [files[0]]
-                targets = execs[0]
-            end
-            check_relationship(sources, targets, out[param], refreshers.include?(param))
-
-            # Now add another relationship
-            if out[param]
-                files[0][param] = execs[1]
-                targets << execs[1]
-                assert_equal(targets.collect { |t| [t.class.name, t.title]},
-                    files[0][param], "Incorrect target list")
-            else
-                execs[0][param] = files[1]
-                sources << files[1]
-                assert_equal(sources.collect { |t| [t.class.name, t.title]},
-                    execs[0][param], "Incorrect source list")
-            end
-            check_relationship(sources, targets, out[param], refreshers.include?(param))
-
-            Puppet::Type.allclear
-        end
-    end
-    
-    def test_munge_relationship
-        file = Puppet::Type.newfile :path => tempfile(), :mode => 0755
-        execs = []
-        3.times do |i|
-            execs << Puppet::Type.newexec(:title => "yay#{i}", :command => "/bin/echo yay")
-        end
-        
-        # First try it with one object, specified as a reference and an array
-        result = nil
-        [execs[0], [:exec, "yay0"], ["exec", "yay0"]].each do |target|
-            assert_nothing_raised do
-                result = file.send(:munge_relationship, :require, target)
-            end
-        
-            assert_equal([[:exec, "yay0"]], result)
-        end
-        
-        # Now try it with multiple objects
-        symbols = execs.collect { |e| [e.class.name, e.title] }
-        strings = execs.collect { |e| [e.class.name.to_s, e.title] }
-        [execs, symbols, strings].each do |target|
-            assert_nothing_raised do
-                result = file.send(:munge_relationship, :require, target)
-            end
-        
-            assert_equal(symbols, result)
-        end
-        
-        # Make sure we can mix it up, even though this shouldn't happen
-        assert_nothing_raised do
-            result = file.send(:munge_relationship, :require, [execs[0], [execs[1].class.name, execs[1].title]])
-        end
-        
-        assert_equal([[:exec, "yay0"], [:exec, "yay1"]], result)
-        
-        # Finally, make sure that new results get added to old.  The only way
-        # to get rid of relationships is to delete the parameter.
-        file[:require] = execs[0]
-        
-        assert_nothing_raised do
-            result = file.send(:munge_relationship, :require, [execs[1], execs[2]])
-        end
-        
-        assert_equal(symbols, result)
-    end
-    
     def test_autorequire
         # We know that execs autorequire their cwd, so we'll use that
         path = tempfile()
-        
-        file = Puppet::Type.newfile(:title => "myfile", :path => path,
+
+        file = Puppet::Type.type(:file).new(:title => "myfile", :path => path,
             :ensure => :directory)
         exec = Puppet::Type.newexec(:title => "myexec", :cwd => path,
             :command => "/bin/echo")
-        
+
+        catalog = mk_catalog(file, exec)
         reqs = nil
         assert_nothing_raised do
             reqs = exec.autorequire
@@ -173,42 +70,18 @@ class TestRelationships < Test::Unit::TestCase
         assert_instance_of(Puppet::Relationship, reqs[0], "Did not return a relationship edge")
         assert_equal(file, reqs[0].source, "Did not set the autorequire source correctly")
         assert_equal(exec, reqs[0].target, "Did not set the autorequire target correctly")
-        
-        # Now make sure that these relationships are added to the 
+
+        # Now make sure that these relationships are added to the
         # relationship graph
-        config = mk_catalog(file, exec)
-        config.apply do |trans|
-            assert(config.relationship_graph.edge?(file, exec), "autorequire edge was not created")
+        catalog.apply do |trans|
+            assert(catalog.relationship_graph.edge?(file, exec), "autorequire edge was not created")
         end
     end
-    
-    def test_requires?
-        # Test the first direction
-        file1 = Puppet::Type.newfile(:title => "one", :path => tempfile,
-            :ensure => :directory)
-        file2 = Puppet::Type.newfile(:title => "two", :path => tempfile,
-            :ensure => :directory)
-        
-        file1[:require] = file2
-        assert(file1.requires?(file2), "requires? failed to catch :require relationship")
-        file1.delete(:require)
-        assert(! file1.requires?(file2), "did not delete relationship")
-        file1[:subscribe] = file2
-        assert(file1.requires?(file2), "requires? failed to catch :subscribe relationship")
-        file1.delete(:subscribe)
-        assert(! file1.requires?(file2), "did not delete relationship")
-        file2[:before] = file1
-        assert(file1.requires?(file2), "requires? failed to catch :before relationship")
-        file2.delete(:before)
-        assert(! file1.requires?(file2), "did not delete relationship")
-        file2[:notify] = file1
-        assert(file1.requires?(file2), "requires? failed to catch :notify relationship")
-    end
-    
+
     # Testing #411.  It was a problem with builddepends.
     def test_missing_deps
-        file = Puppet::Type.newfile :path => tempfile, :require => ["file", "/no/such/file"]
-        
+        file = Puppet::Type.type(:file).new :path => tempfile, :require => Puppet::Resource::Reference.new("file", "/no/such/file")
+
         assert_raise(Puppet::Error) do
             file.builddepends
         end