puppet 0.18.4 → 0.22.4

data/test/certmgr/ca.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/sslcertificates/ca.rb'
+require 'puppettest'
+require 'puppettest/certificates'
+
+class TestCA < Test::Unit::TestCase
+    include PuppetTest
+    def hosts
+        %w{host.domain.com Other.Testing.Com}
+    end
+    def mkca
+        Puppet::SSLCertificates::CA.new
+    end
+    
+    def test_clean
+        dirs = [:csrdir, :signeddir, :publickeydir, :privatekeydir, :certdir]
+        ca = mkca
+        
+        hosts.each do |host|
+            files = []
+            dirs.each do |dir|
+                dir = Puppet[dir]
+                # We handle case insensitivity through downcasing
+                file = File.join(dir, host.downcase + ".pem")
+                File.open(file, "w") do |f|
+                    f.puts "testing"
+                end
+                files << file
+            end
+            assert_nothing_raised do
+                ca.clean(host)
+            end
+            files.each do |f|
+                assert(! FileTest.exists?(f), "File %s was not deleted" % f)
+            end
+        end
+    end
+    
+    def test_host2Xfile
+        ca = mkca
+        hosts.each do |host|
+            {:signeddir => :host2certfile, :csrdir => :host2csrfile}.each do |dir, method|
+                val = nil
+                assert_nothing_raised do
+                    val = ca.send(method, host)
+                end
+                assert_equal(File.join(Puppet[dir], host.downcase + ".pem"), val,
+                    "incorrect response from %s" % method)
+            end
+        end
+    end
+    
+    def test_list
+        ca = mkca
+        # Make a fake csr
+        dir = Puppet[:csrdir]
+        list = []
+        hosts.each do |host|
+            file = File.join(dir, host.downcase + ".pem")
+            File.open(file, "w") { |f| f.puts "yay" }
+            list << host.downcase
+        end
+        
+        assert_equal(list.sort, ca.list.sort, "list was not correct")
+    end
+
+    # #142 - test storing the public key
+    def test_store_public_key
+        ca = mkca
+        assert_nothing_raised do
+            ca.mkrootcert
+        end
+        assert(FileTest.exists?(Puppet[:capub]), "did not store public key")
+    end
+end
+
+# $Id: ca.rb 2232 2007-02-27 22:14:56Z luke $

data/test/certmgr/certmgr.rb

@@ -1,27 +1,14 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/sslcertificates.rb'
-require 'test/unit'
 require 'puppettest'
-
-# so, what kind of things do we want to test?
-
-# we don't need to test function, since we're confident in the
-# library tests.  We do, however, need to test how things are actually
-# working in the language.
-
-# so really, we want to do things like test that our ast is correct
-# and test whether we've got things in the right scopes
+require 'puppettest/certificates'
 
 class TestCertMgr < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest::Certificates
     def setup
         super
         #@dir = File.join(Puppet[:certdir], "testing")
@@ -29,28 +16,6 @@ class TestCertMgr < Test::Unit::TestCase
         system("mkdir -p %s" % @dir)
     end
 
-    def mkPassFile()
-        keyfile = File.join(@dir, "tmpkeyfile")
-        @@tmpfiles << keyfile
-        unless FileTest.exists?(@dir)
-            system("mkdir -p %s" % @dir)
-        end
-        File.open(keyfile, "w", 0600) { |f|
-            f.print "as;dklj23rlkjzdflij23wr"
-        }
-
-        return keyfile
-    end
-
-    def mkCA
-        ca = nil
-        assert_nothing_raised {
-            ca = Puppet::SSLCertificates::CA.new()
-        }
-
-        return ca
-    end
-
     def testCreateSelfSignedCertificate
         cert = nil
         name = "testing"
@@ -154,7 +119,7 @@ class TestCertMgr < Test::Unit::TestCase
         assert_nothing_raised {
             cert = Puppet::SSLCertificates::Certificate.new(
                 :name => "signedcertest",
-                :state => "TN",
+                :property => "TN",
                 :city => "Nashville",
                 :country => "US",
                 :email => "luke@madstop.com",
@@ -196,16 +161,6 @@ class TestCertMgr < Test::Unit::TestCase
         assert_equal($?,0)
         assert_equal(File.join(Puppet[:certdir], "signedcertest.pem: OK\n"), output)
     end
-
-    def mkcert(hostname)
-        cert = nil
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(:name => hostname)
-            cert.mkcsr
-        }
-        
-        return cert
-    end 
  
 
     def test_interactiveca
@@ -261,4 +216,76 @@ class TestCertMgr < Test::Unit::TestCase
         }
         assert_nil(cert)
     end
+
+    def test_crl
+        ca = mkCA()
+        h1 = mksignedcert(ca, "host1.example.com")
+        h2 = mksignedcert(ca, "host2.example.com")
+        
+        assert(ca.cert.verify(ca.cert.public_key))
+        assert(h1.verify(ca.cert.public_key))
+        assert(h2.verify(ca.cert.public_key))
+
+        crl = ca.crl
+        assert_not_nil(crl)
+        
+        store = mkStore(ca)
+        assert( store.verify(ca.cert))
+        assert( store.verify(h1, [ca.cert]))
+        assert( store.verify(h2, [ca.cert]))
+
+        ca.revoke(h1.serial)
+
+        # Recreate the CA from disk
+        ca = mkCA()
+        store = mkStore(ca)
+        assert( store.verify(ca.cert))
+        assert(!store.verify(h1, [ca.cert]))
+        assert( store.verify(h2, [ca.cert]))
+        
+        Puppet.err :yay
+        ca.revoke(h2.serial)
+        assert_equal(1, ca.crl.extensions.size)
+
+        # Recreate the CA from disk
+        ca = mkCA()
+        store = mkStore(ca)
+        assert( store.verify(ca.cert))
+        assert(!store.verify(h1, [ca.cert]), "first revoked cert passed")
+        assert(!store.verify(h2, [ca.cert]), "second revoked cert passed")
+    end
+
+    def test_ttl
+        cert = mksignedcert
+        assert_equal(5 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
+
+        Puppet[:ca_ttl] = 7 * 24 * 60 * 60
+        cert = mksignedcert
+        assert_equal(7 * 24 * 60 * 60,  cert.not_after - cert.not_before)
+
+        Puppet[:ca_ttl] = "2y"
+        cert = mksignedcert
+        assert_equal(2 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
+
+        Puppet[:ca_ttl] = "2y"
+        cert = mksignedcert
+        assert_equal(2 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
+
+        Puppet[:ca_ttl] = "1h"
+        cert = mksignedcert
+        assert_equal(60 * 60,  cert.not_after - cert.not_before)
+
+        Puppet[:ca_ttl] = "900s"
+        cert = mksignedcert
+        assert_equal(900,  cert.not_after - cert.not_before)
+
+        # This needs to be last, to make sure that setting ca_days
+        # overrides setting ca_ttl
+        Puppet[:ca_days] = 3
+        cert = mksignedcert
+        assert_equal(3 * 24 * 60 * 60,  cert.not_after - cert.not_before)
+
+    end
 end
+
+# $Id: certmgr.rb 2169 2007-02-07 06:47:10Z luke $

data/test/certmgr/inventory.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppettest/certificates'
+require 'puppet/sslcertificates/inventory.rb'
+
+class TestCertInventory < Test::Unit::TestCase
+    include PuppetTest::Certificates
+
+    Inventory = Puppet::SSLCertificates::Inventory
+
+    def test_format
+        cert = mksignedcert
+
+        format = nil
+        assert_nothing_raised do
+            format = Inventory.format(cert)
+        end
+
+        assert(format =~ /^0x0001 \S+ \S+ #{cert.subject}/,
+            "Did not create correct format")
+    end
+
+    def test_init
+        # First create a couple of certificates
+        ca = mkCA
+
+        cert1 = mksignedcert(ca, "host1.madstop.com")
+        cert2 = mksignedcert(ca, "host2.madstop.com")
+
+        init = nil
+        assert_nothing_raised do
+            init = Inventory.init
+        end
+
+        [cert1, cert2].each do |cert|
+            assert(init.include?(cert.subject.to_s),
+                "Did not catch %s" % cert.subject.to_s)
+        end
+    end
+
+    def test_add
+        certs = []
+
+        user = Puppet::Util.uid(Puppet[:user])
+
+        ca = mkCA
+        3.times do |i|
+            cert = mksignedcert(ca, "host#{i.to_s}.domain.com")
+            certs << cert
+
+            # Add the cert
+            assert_nothing_raised do
+                Puppet::SSLCertificates::Inventory.add(cert)
+            end
+
+            # Now make sure the cert is in there
+            assert(FileTest.exists?(Puppet[:cert_inventory]),
+                "Inventory file was not created")
+
+            # And make sure all of our certs are in there
+            certs.each do |c|
+                assert(
+                    File.read(Puppet[:cert_inventory]).include?(cert.subject.to_s),
+                    "File does not contain %s" % cert.subject.to_s
+                )
+            end
+
+            # And make sure the inventory file is owned by the right user
+            if Process.uid == 0
+                assert_equal(user, File.stat(Puppet[:cert_inventory]).uid)
+            end
+        end
+    end
+end
+
+# $Id: inventory.rb 1835 2006-11-08 05:22:24Z luke $

data/test/certmgr/support.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/sslcertificates/support'
+
+class TestCertSupport < Test::Unit::TestCase
+    include PuppetTest
+    MissingCertificate = Puppet::SSLCertificates::Support::MissingCertificate
+
+    class CertUser
+        include Puppet::SSLCertificates::Support
+    end
+
+    def setup
+        super
+        @user = CertUser.new
+        @ca = Puppet::SSLCertificates::CA.new
+        @client = Puppet::Network::Client.ca.new(:CA => @ca)
+    end
+
+    # Yay, metaprogramming
+    def test_keytype
+        [:key, :csr, :cert, :ca_cert].each do |name|
+            assert(Puppet::SSLCertificates::Support.method_defined?(name),
+                "No retrieval method for %s" % name)
+            maker = "mk_%s" % name
+            assert(Puppet::SSLCertificates::Support.method_defined?(maker),
+                "No maker method for %s" % name)
+        end
+    end
+
+    def test_keys
+        keys = [:hostprivkey, :hostpubkey].each { |n| Puppet[n] = tempfile }
+
+        key = nil
+        assert_nothing_raised do
+            key = @user.key
+        end
+
+        assert_logged(:info, /Creating a new SSL/, "Did not log about new key")
+        keys.each do |file|
+            assert(FileTest.exists?(Puppet[file]),
+                "Did not create %s key file" % file)
+        end
+
+        # Make sure it's a valid key
+        assert_nothing_raised("Created key is invalid") do
+            OpenSSL::PKey::RSA.new(File.read(Puppet[:hostprivkey]))
+        end
+
+        # now make sure we can read it in
+        other = CertUser.new
+        assert_nothing_raised("Could not read key in") do
+            other.key
+        end
+
+        assert_equal(@user.key.to_s, other.key.to_s, "Keys are not equal")
+    end
+
+    def test_csr
+        csr = nil
+        assert_nothing_raised("Could not create csr") do
+            csr = @user.csr
+        end
+
+        assert(FileTest.exists?(Puppet[:hostcsr]), "did not create csr file")
+        assert_instance_of(OpenSSL::X509::Request, csr)
+    end
+
+    def test_cacert
+        @user = CertUser.new
+
+        assert_raise(MissingCertificate, "Did not fail when missing cacert") do
+            @user.ca_cert
+        end
+    end
+end
+
+# $Id: support.rb 2259 2007-03-06 19:03:05Z luke $

data/test/executables/filebucket.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/network/client'
+require 'puppettest'
+require 'socket'
+require 'facter'
+
+class TestFileBucketExe < Test::Unit::TestCase
+    include PuppetTest::ExeTest
+
+    def test_local
+        bucket = tempfile
+        file = tempfile
+        text = "somet ext"
+        md5 = Digest::MD5.hexdigest(text)
+        File.open(file, "w") { |f| f.print text }
+        out = %x{filebucket --bucket #{bucket} backup #{file}}
+
+        outfile, outmd5 = out.chomp.split(": ")
+
+        assert_equal(0, $?, "filebucket did not run successfully")
+
+        assert_equal(file, outfile, "did not output correct file name")
+        assert_equal(md5, outmd5, "did not output correct md5 sum")
+
+        dipper = Puppet::Network::Client.dipper.new(:Path => bucket)
+
+        newtext = nil
+        assert_nothing_raised("Could not get file from bucket") do
+            newtext = dipper.getfile(md5)
+        end
+
+        assert_equal(text, newtext, "did not get correct file from md5 sum")
+
+        out = %x{filebucket --bucket #{bucket} get #{md5}}
+        assert_equal(0, $?, "filebucket did not run successfully")
+        assert_equal(text, out, "did not get correct text back from filebucket")
+
+        File.open(file, "w") { |f| f.puts "some other txt" }
+        out = %x{filebucket --bucket #{bucket} restore #{file} #{md5}}
+        assert_equal(0, $?, "filebucket did not run successfully")
+        assert_equal(text, File.read(file), "file was not restored")
+    end
+end
+
+# $Id: filebucket.rb 2349 2007-03-24 21:17:37Z luke $