puppet 0.25.5 → 2.6.0

data/test/network/client/ca.rb

@@ -8,64 +8,62 @@ require 'puppet/network/client/ca'
 require 'puppet/sslcertificates/support'
 
 class TestClientCA < Test::Unit::TestCase
-    include PuppetTest::ServerTest
+  include PuppetTest::ServerTest
 
-    def setup
-        Puppet::Util::SUIDManager.stubs(:asuser).yields
-        super
-        @ca = Puppet::Network::Handler.ca.new
-        @client = Puppet::Network::Client.ca.new :CA => @ca
-    end
-
-    def test_request_cert
-        assert_nothing_raised("Could not request cert") do
-            @client.request_cert
-        end
+  def setup
+    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    super
+    @ca = Puppet::Network::Handler.ca.new
+    @client = Puppet::Network::Client.ca.new :CA => @ca
+  end
 
-        [:hostprivkey, :hostcert, :localcacert].each do |name|
-            assert(FileTest.exists?(Puppet.settings[name]),
-                "Did not create cert %s" % name)
-        end
+  def test_request_cert
+    assert_nothing_raised("Could not request cert") do
+      @client.request_cert
     end
 
-    # Make sure the ca defaults to specific ports and names
-    def test_ca_server
-        Puppet.settings.stubs(:value).returns "eh"
-        Puppet.settings.expects(:value).with(:ca_server).returns("myca")
-        Puppet.settings.expects(:value).with(:ca_port).returns(321)
-        Puppet.settings.stubs(:value).with(:http_proxy_host).returns(nil)
-        Puppet.settings.stubs(:value).with(:http_proxy_port).returns(nil)
-        Puppet.settings.stubs(:value).with(:http_keepalive).returns(false)
-        Puppet.settings.stubs(:value).with(:configtimeout).returns(180)
-
-        # Just throw an error; the important thing is the values, not what happens next.
-        Net::HTTP.stubs(:new).with("myca", 321, nil, nil).raises(ArgumentError)
-        assert_raise(ArgumentError) { Puppet::Network::Client.ca.new }
+    [:hostprivkey, :hostcert, :localcacert].each do |name|
+      assert(FileTest.exists?(Puppet.settings[name]), "Did not create cert #{name}")
     end
+  end
 
-    # #578
-    def test_invalid_certs_are_not_written
-        # Run the get once, which should be valid
+  # Make sure the ca defaults to specific ports and names
+  def test_ca_server
+    Puppet.settings.stubs(:value).returns "eh"
+    Puppet.settings.expects(:value).with(:ca_server).returns("myca")
+    Puppet.settings.expects(:value).with(:ca_port).returns(321)
+    Puppet.settings.stubs(:value).with(:http_proxy_host).returns(nil)
+    Puppet.settings.stubs(:value).with(:http_proxy_port).returns(nil)
+    Puppet.settings.stubs(:value).with(:http_keepalive).returns(false)
+    Puppet.settings.stubs(:value).with(:configtimeout).returns(180)
 
-        assert_nothing_raised("Could not get a certificate") do
-            @client.request_cert
-        end
+    # Just throw an error; the important thing is the values, not what happens next.
+    Net::HTTP.stubs(:new).with("myca", 321, nil, nil).raises(ArgumentError)
+    assert_raise(ArgumentError) { Puppet::Network::Client.ca.new }
+  end
 
-        # Now remove the cert and keys, so we get a broken cert
-        File.unlink(Puppet[:hostcert])
-        File.unlink(Puppet[:localcacert])
-        File.unlink(Puppet[:hostprivkey])
+  # #578
+  def test_invalid_certs_are_not_written
+    # Run the get once, which should be valid
 
-        @client = Puppet::Network::Client.ca.new :CA => @ca
-        @ca.expects(:getcert).returns("yay") # not a valid cert
-        # Now make sure it fails, since we'll get the old cert but have new keys
-        assert_raise(Puppet::Network::Client::CA::InvalidCertificate, "Did not fail on invalid cert") do
-            @client.request_cert
-        end
+    assert_nothing_raised("Could not get a certificate") do
+      @client.request_cert
+    end
+
+    # Now remove the cert and keys, so we get a broken cert
+    File.unlink(Puppet[:hostcert])
+    File.unlink(Puppet[:localcacert])
+    File.unlink(Puppet[:hostprivkey])
 
-        # And then make sure the cert isn't written to disk
-        assert(! FileTest.exists?(Puppet[:hostcert]),
-            "Invalid cert got written to disk")
+    @client = Puppet::Network::Client.ca.new :CA => @ca
+    @ca.expects(:getcert).returns("yay") # not a valid cert
+    # Now make sure it fails, since we'll get the old cert but have new keys
+    assert_raise(Puppet::Network::Client::CA::InvalidCertificate, "Did not fail on invalid cert") do
+      @client.request_cert
     end
+
+    # And then make sure the cert isn't written to disk
+    assert(! FileTest.exists?(Puppet[:hostcert]), "Invalid cert got written to disk")
+  end
 end
 

data/test/network/client/dipper.rb

@@ -3,32 +3,32 @@
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
-require 'puppet/network/client/resource'
+require 'puppet/file_bucket/dipper'
 
 class TestDipperClient < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def setup
-        super
-        @dipper = Puppet::Network::Client.dipper.new(:Path => tempfile)
+  include PuppetTest::ServerTest
+
+  def setup
+    super
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => tempfile)
+  end
+
+  # Make sure we can create a new file with 'restore'.
+  def test_restore_to_new_file
+    file = tempfile
+    text = "asdf;lkajseofiqwekj"
+    File.open(file, "w") { |f| f.puts text }
+    md5 = nil
+    assert_nothing_raised("Could not send file") do
+      md5 = @dipper.backup(file)
     end
 
-    # Make sure we can create a new file with 'restore'.
-    def test_restore_to_new_file
-        file = tempfile
-        text = "asdf;lkajseofiqwekj"
-        File.open(file, "w") { |f| f.puts text }
-        md5 = nil
-        assert_nothing_raised("Could not send file") do
-            md5 = @dipper.backup(file)
-        end
-
-        newfile = tempfile
-        assert_nothing_raised("could not restore to new path") do
-            @dipper.restore(newfile, md5)
-        end
-
-        assert_equal(File.read(file), File.read(newfile), "did not restore correctly")
+    newfile = tempfile
+    assert_nothing_raised("could not restore to new path") do
+      @dipper.restore(newfile, md5)
     end
+
+    assert_equal(File.read(file), File.read(newfile), "did not restore correctly")
+  end
 end
 

data/test/network/client_request.rb

@@ -7,32 +7,32 @@ require 'puppettest'
 require 'puppet/network/client_request'
 
 class TestClientRequest < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def test_initialize
-        req = nil
-        assert_nothing_raised do
-            req = Puppet::Network::ClientRequest.new("name", "ip", false)
-        end
+  def test_initialize
+    req = nil
+    assert_nothing_raised do
+      req = Puppet::Network::ClientRequest.new("name", "ip", false)
+    end
 
-        assert_equal("name", req.name, "host name was not set correctly")
-        assert_equal("ip", req.ip, "host ip was not set correctly")
-        assert_equal(false, req.authenticated, "host auth was not set correctly")
-        assert(! req.authenticated, "host was incorrectly considered authenticated")
+    assert_equal("name", req.name, "host name was not set correctly")
+    assert_equal("ip", req.ip, "host ip was not set correctly")
+    assert_equal(false, req.authenticated, "host auth was not set correctly")
+    assert(! req.authenticated, "host was incorrectly considered authenticated")
 
-        req.authenticated = true
-        assert(req.authenticated, "host was not considered authenticated")
+    req.authenticated = true
+    assert(req.authenticated, "host was not considered authenticated")
 
-        assert_raise(ArgumentError) do
-            req.call
-        end
+    assert_raise(ArgumentError) do
+      req.call
+    end
 
-        req.handler = "yay"
-        req.method = "foo"
-        assert_equal("yay.foo", req.call, "call was not built correctly")
+    req.handler = "yay"
+    req.method = "foo"
+    assert_equal("yay.foo", req.call, "call was not built correctly")
 
-        assert_equal("name(ip)", req.to_s, "request string not correct")
-    end
+    assert_equal("name(ip)", req.to_s, "request string not correct")
+  end
 end
 
 

data/test/network/handler/ca.rb

@@ -6,269 +6,268 @@ require 'puppettest'
 require 'puppet/network/handler/ca'
 require 'mocha'
 
-if ARGV.length > 0 and ARGV[0] == "short"
-    $short = true
-else
-    $short = false
-end
+$short = (ARGV.length > 0 and ARGV[0] == "short")
 
 class TestCA < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def setup
-        Puppet::Util::SUIDManager.stubs(:asuser).yields
-        super
-    end
-
-    # Verify that we're autosigning.  We have to autosign a "different" machine,
-    # since we always autosign the CA server's certificate.
-    def test_autocertgeneration
-        ca = nil
-
-        # create our ca
-        assert_nothing_raised {
-            ca = Puppet::Network::Handler.ca.new(:autosign => true)
-        }
-
-        # create a cert with a fake name
-        key = nil
-        csr = nil
-        cert = nil
-        hostname = "test.domain.com"
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(
-                :name => "test.domain.com"
-            )
-        }
-
-        # make the request
-        assert_nothing_raised {
-            cert.mkcsr
-        }
-
-        # and get it signed
-        certtext = nil
-        cacerttext = nil
-        assert_nothing_raised {
-            certtext, cacerttext = ca.getcert(cert.csr.to_s)
-        }
-
-        # they should both be strings
-        assert_instance_of(String, certtext)
-        assert_instance_of(String, cacerttext)
-
-        # and they should both be valid certs
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(certtext)
-        }
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(cacerttext)
-        }
-
-        # and pull it again, just to make sure we're getting the same thing
-        newtext = nil
-        assert_nothing_raised {
-            newtext, cacerttext = ca.getcert(
-                cert.csr.to_s, "test.puppetlabs.com", "127.0.0.1"
-            )
-        }
-
-        assert_equal(certtext,newtext)
-    end
-
-    # this time don't use autosign
-    def test_storeAndSign
-        ca = nil
-        caserv = nil
-
-        # make our CA server
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new(:autosign => false)
-        }
-
-        # retrieve the actual ca object
-        assert_nothing_raised {
-            ca = caserv.ca
-        }
-
-        # make our test cert again
-        key = nil
-        csr = nil
-        cert = nil
-        hostname = "test.domain.com"
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(
-                :name => "anothertest.domain.com"
-            )
-        }
-        # and the CSR
-        assert_nothing_raised {
-            cert.mkcsr
-        }
-
-        # retrieve them
-        certtext = nil
-        assert_nothing_raised {
-            certtext, cacerttext = caserv.getcert(
-                cert.csr.to_s, "test.puppetlabs.com", "127.0.0.1"
-            )
-        }
-
-        # verify we got nothing back, since autosign is off
-        assert_equal("", certtext)
-
-        # now sign it manually, with the CA object
-        x509 = nil
-        assert_nothing_raised {
-            x509, cacert = ca.sign(cert.csr)
-        }
-
-        # and write it out
-        cert.cert = x509
-        assert_nothing_raised {
-            cert.write
-        }
+  include PuppetTest::ServerTest
+
+  def setup
+    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    super
+  end
+
+  # Verify that we're autosigning.  We have to autosign a "different" machine,
+  # since we always autosign the CA server's certificate.
+  def test_autocertgeneration
+    ca = nil
+
+    # create our ca
+    assert_nothing_raised {
+      ca = Puppet::Network::Handler.ca.new(:autosign => true)
+    }
+
+    # create a cert with a fake name
+    key = nil
+    csr = nil
+    cert = nil
+    hostname = "test.domain.com"
+    assert_nothing_raised {
+      cert = Puppet::SSLCertificates::Certificate.new(
+        :name => "test.domain.com"
+      )
+    }
+
+    # make the request
+    assert_nothing_raised {
+      cert.mkcsr
+    }
+
+    # and get it signed
+    certtext = nil
+    cacerttext = nil
+    assert_nothing_raised {
+      certtext, cacerttext = ca.getcert(cert.csr.to_s)
+    }
+
+    # they should both be strings
+    assert_instance_of(String, certtext)
+    assert_instance_of(String, cacerttext)
+
+    # and they should both be valid certs
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(certtext)
+    }
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(cacerttext)
+    }
+
+    # and pull it again, just to make sure we're getting the same thing
+    newtext = nil
+    assert_nothing_raised {
+      newtext, cacerttext = ca.getcert(
+        cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
+      )
+    }
+
+    assert_equal(certtext,newtext)
+  end
+
+  # this time don't use autosign
+  def test_storeAndSign
+    ca = nil
+    caserv = nil
+
+    # make our CA server
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new(:autosign => false)
+    }
+
+    # retrieve the actual ca object
+    assert_nothing_raised {
+      ca = caserv.ca
+    }
+
+    # make our test cert again
+    key = nil
+    csr = nil
+    cert = nil
+    hostname = "test.domain.com"
+    assert_nothing_raised {
+      cert = Puppet::SSLCertificates::Certificate.new(
+        :name => "anothertest.domain.com"
+      )
+    }
+    # and the CSR
+    assert_nothing_raised {
+      cert.mkcsr
+    }
+
+    # retrieve them
+    certtext = nil
+    assert_nothing_raised {
+      certtext, cacerttext = caserv.getcert(
+        cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
+      )
+    }
+
+    # verify we got nothing back, since autosign is off
+    assert_equal("", certtext)
+
+    # now sign it manually, with the CA object
+    x509 = nil
+    assert_nothing_raised {
+      x509, cacert = ca.sign(cert.csr)
+    }
+
+    # and write it out
+    cert.cert = x509
+    assert_nothing_raised {
+      cert.write
+    }
+
+    assert(File.exists?(cert.certfile))
+
+    # now get them again, and verify that we actually get them
+    newtext = nil
+    assert_nothing_raised {
+      newtext, cacerttext  = caserv.getcert(cert.csr.to_s)
+    }
+
+    assert(newtext)
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(newtext)
+    }
+
+    # Now verify that we can clean a given host's certs
+    assert_nothing_raised {
+      ca.clean("anothertest.domain.com")
+    }
+
+    assert(!File.exists?(cert.certfile), "Cert still exists after clean")
+  end
+
+  # and now test the autosign file
+  def test_autosign
+    autosign = File.join(tmpdir, "autosigntesting")
+    @@tmpfiles << autosign
+    File.open(autosign, "w") { |f|
+      f.puts "hostmatch.domain.com"
+      f.puts "*.other.com"
+    }
+
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new(:autosign => autosign)
+    }
+
+    # make sure we know what's going on
+    assert(caserv.autosign?("hostmatch.domain.com"))
+    assert(caserv.autosign?("fakehost.other.com"))
+    assert(!caserv.autosign?("kirby.reductivelabs.com"))
+    assert(!caserv.autosign?("culain.domain.com"))
+  end
+
+  # verify that things aren't autosigned by default
+  def test_nodefaultautosign
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new
+    }
+
+    # make sure we know what's going on
+    assert(!caserv.autosign?("hostmatch.domain.com"))
+    assert(!caserv.autosign?("fakehost.other.com"))
+    assert(!caserv.autosign?("kirby.reductivelabs.com"))
+    assert(!caserv.autosign?("culain.domain.com"))
+  end
+
+  # We want the CA to autosign its own certificate, because otherwise
+  # the puppetmasterd CA does not autostart.
+  def test_caautosign
+    server = nil
+    Puppet.stubs(:master?).returns true
+    assert_nothing_raised {
 
-        assert(File.exists?(cert.certfile))
-
-        # now get them again, and verify that we actually get them
-        newtext = nil
-        assert_nothing_raised {
-            newtext, cacerttext  = caserv.getcert(cert.csr.to_s)
-        }
-
-        assert(newtext)
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(newtext)
-        }
-
-        # Now verify that we can clean a given host's certs
-        assert_nothing_raised {
-            ca.clean("anothertest.domain.com")
-        }
-
-        assert(!File.exists?(cert.certfile), "Cert still exists after clean")
-    end
-
-    # and now test the autosign file
-    def test_autosign
-        autosign = File.join(tmpdir, "autosigntesting")
-        @@tmpfiles << autosign
-        File.open(autosign, "w") { |f|
-            f.puts "hostmatch.domain.com"
-            f.puts "*.other.com"
-        }
-
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new(:autosign => autosign)
-        }
-
-        # make sure we know what's going on
-        assert(caserv.autosign?("hostmatch.domain.com"))
-        assert(caserv.autosign?("fakehost.other.com"))
-        assert(!caserv.autosign?("kirby.puppetlabs.com"))
-        assert(!caserv.autosign?("culain.domain.com"))
-    end
-
-    # verify that things aren't autosigned by default
-    def test_nodefaultautosign
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new()
-        }
-
-        # make sure we know what's going on
-        assert(!caserv.autosign?("hostmatch.domain.com"))
-        assert(!caserv.autosign?("fakehost.other.com"))
-        assert(!caserv.autosign?("kirby.puppetlabs.com"))
-        assert(!caserv.autosign?("culain.domain.com"))
-    end
-
-    # We want the CA to autosign its own certificate, because otherwise
-    # the puppetmasterd CA does not autostart.
-    def test_caautosign
-        server = nil
-        Puppet[:name] = "puppetmasterd"
-        assert_nothing_raised {
             server = Puppet::Network::HTTPServer::WEBrick.new(
-                :Port => @@port,
-                :Handlers => {
-                    :CA => {}, # so that certs autogenerate
-                    :Status => nil
-                }
-            )
+                
+        :Port => @@port,
+        
+        :Handlers => {
+          :CA => {}, # so that certs autogenerate
+          :Status => nil
         }
+      )
+    }
+  end
+
+  # Make sure true/false causes the file to be ignored.
+  def test_autosign_true_beats_file
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new
+    }
+
+    host = "hostname.domain.com"
+
+    # Create an autosign file
+    file = tempfile
+    Puppet[:autosign] = file
+
+    File.open(file, "w") { |f|
+      f.puts host
+    }
+
+    # Start with "false"
+    Puppet[:autosign] = false
+
+    assert(! caserv.autosign?(host), "Host was incorrectly autosigned")
+
+    # Then set it to true
+    Puppet[:autosign] = true
+    assert(caserv.autosign?(host), "Host was not autosigned")
+    # And try a different host
+    assert(caserv.autosign?("other.yay.com"), "Host was not autosigned")
+
+    # And lastly the file
+    Puppet[:autosign] = file
+    assert(caserv.autosign?(host), "Host was not autosigned")
+
+    # And try a different host
+    assert(! caserv.autosign?("other.yay.com"), "Host was autosigned")
+  end
+
+  # Make sure that a CSR created with keys that don't match the existing
+  # cert throws an exception on the server.
+  def test_mismatched_public_keys_throws_exception
+    ca = Puppet::Network::Handler.ca.new
+
+    # First initialize the server
+    client = Puppet::Network::Client.ca.new :CA => ca
+    client.request_cert
+    File.unlink(Puppet[:hostcsr])
+
+    # Now use a different cert name
+    Puppet[:certname] = "my.host.com"
+    client = Puppet::Network::Client.ca.new :CA => ca
+    firstcsr = client.csr
+    File.unlink(Puppet[:hostcsr]) if FileTest.exists?(Puppet[:hostcsr])
+
+    assert_nothing_raised("Could not get cert") do
+      ca.getcert(firstcsr.to_s)
     end
 
-    # Make sure true/false causes the file to be ignored.
-    def test_autosign_true_beats_file
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new()
-        }
-
-        host = "hostname.domain.com"
-
-        # Create an autosign file
-        file = tempfile()
-        Puppet[:autosign] = file
-
-        File.open(file, "w") { |f|
-            f.puts host
-        }
-
-        # Start with "false"
-        Puppet[:autosign] = false
-
-        assert(! caserv.autosign?(host), "Host was incorrectly autosigned")
-
-        # Then set it to true
-        Puppet[:autosign] = true
-        assert(caserv.autosign?(host), "Host was not autosigned")
-        # And try a different host
-        assert(caserv.autosign?("other.yay.com"), "Host was not autosigned")
-
-        # And lastly the file
-        Puppet[:autosign] = file
-        assert(caserv.autosign?(host), "Host was not autosigned")
-
-        # And try a different host
-        assert(! caserv.autosign?("other.yay.com"), "Host was autosigned")
-    end
-
-    # Make sure that a CSR created with keys that don't match the existing
-    # cert throws an exception on the server.
-    def test_mismatched_public_keys_throws_exception
-        ca = Puppet::Network::Handler.ca.new()
-
-        # First initialize the server
-        client = Puppet::Network::Client.ca.new :CA => ca
-        client.request_cert
-        File.unlink(Puppet[:hostcsr])
-
-        # Now use a different cert name
-        Puppet[:certname] = "my.host.com"
-        client = Puppet::Network::Client.ca.new :CA => ca
-        firstcsr = client.csr
-        File.unlink(Puppet[:hostcsr]) if FileTest.exists?(Puppet[:hostcsr])
-
-        assert_nothing_raised("Could not get cert") do
-            ca.getcert(firstcsr.to_s)
-        end
-
-        # Now get rid of the public key, forcing a new csr
-        File.unlink(Puppet[:hostprivkey])
+    # Now get rid of the public key, forcing a new csr
+    File.unlink(Puppet[:hostprivkey])
 
-        client = Puppet::Network::Client.ca.new :CA => ca
+    client = Puppet::Network::Client.ca.new :CA => ca
 
-        second_csr = client.csr
+    second_csr = client.csr
 
-        assert(firstcsr.to_s != second_csr.to_s, "CSR did not change")
+    assert(firstcsr.to_s != second_csr.to_s, "CSR did not change")
 
-        assert_raise(Puppet::Error, "CA allowed mismatched keys") do
-            ca.getcert(second_csr.to_s)
-        end
+    assert_raise(Puppet::Error, "CA allowed mismatched keys") do
+      ca.getcert(second_csr.to_s)
     end
+  end
 end