puppet 0.25.5 → 2.6.0

data/spec/unit/ssl/inventory_spec.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/ssl/inventory'
+
+describe Puppet::SSL::Inventory do
+  before do
+    @class = Puppet::SSL::Inventory
+  end
+
+  it "should use the :certinventory setting for the path to the inventory file" do
+    Puppet.settings.expects(:value).with(:cert_inventory).returns "/inven/tory"
+
+    @class.any_instance.stubs(:rebuild)
+
+    @class.new.path.should == "/inven/tory"
+  end
+
+  describe "when initializing" do
+    it "should set its path to the inventory file" do
+      Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
+      @class.new.path.should == "/inven/tory"
+    end
+  end
+
+  describe "when managing an inventory" do
+    before do
+      Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
+
+      FileTest.stubs(:exist?).with("/inven/tory").returns true
+
+      @inventory = @class.new
+
+      @cert = mock 'cert'
+    end
+
+    describe "and creating the inventory file" do
+      before do
+        Puppet.settings.stubs(:write)
+        FileTest.stubs(:exist?).with("/inven/tory").returns false
+
+        Puppet::SSL::Certificate.stubs(:search).returns []
+      end
+
+      it "should log that it is building a new inventory file" do
+        Puppet.expects(:notice)
+
+        @inventory.rebuild
+      end
+
+      it "should use the Settings to write to the file" do
+        Puppet.settings.expects(:write).with(:cert_inventory)
+
+        @inventory.rebuild
+      end
+
+      it "should add a header to the file" do
+        fh = mock 'filehandle'
+        Puppet.settings.stubs(:write).yields fh
+        fh.expects(:print).with { |str| str =~ /^#/ }
+
+        @inventory.rebuild
+      end
+
+      it "should add formatted information on all existing certificates" do
+        cert1 = mock 'cert1'
+        cert2 = mock 'cert2'
+
+        Puppet::SSL::Certificate.expects(:search).with("*").returns [cert1, cert2]
+
+        @class.any_instance.expects(:add).with(cert1)
+        @class.any_instance.expects(:add).with(cert2)
+
+        @inventory.rebuild
+      end
+    end
+
+    describe "and adding a certificate" do
+      it "should build the inventory file if one does not exist" do
+        Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
+        Puppet.settings.stubs(:write)
+
+        FileTest.expects(:exist?).with("/inven/tory").returns false
+
+        @inventory.expects(:rebuild)
+
+        @inventory.add(@cert)
+      end
+
+      it "should use the Settings to write to the file" do
+        Puppet.settings.expects(:write).with(:cert_inventory, "a")
+
+        @inventory.add(@cert)
+      end
+
+      it "should use the actual certificate if it was passed a Puppet certificate" do
+        cert = Puppet::SSL::Certificate.new("mycert")
+        cert.content = @cert
+
+        fh = stub 'filehandle', :print => nil
+        Puppet.settings.stubs(:write).yields fh
+
+        @inventory.expects(:format).with(@cert)
+
+        @inventory.add(@cert)
+      end
+
+      it "should add formatted certificate information to the end of the file" do
+        fh = mock 'filehandle'
+
+        Puppet.settings.stubs(:write).yields fh
+
+        @inventory.expects(:format).with(@cert).returns "myformat"
+
+        fh.expects(:print).with("myformat")
+
+        @inventory.add(@cert)
+      end
+    end
+
+    describe "and formatting a certificate" do
+      before do
+        @cert = stub 'cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15
+      end
+
+      it "should print the serial number as a 4 digit hex number in the first field" do
+        @inventory.format(@cert).split[0].should == "0x000f" # 15 in hex
+      end
+
+      it "should print the not_before date in '%Y-%m-%dT%H:%M:%S%Z' format in the second field" do
+        @cert.not_before.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "before_time"
+
+        @inventory.format(@cert).split[1].should == "before_time"
+      end
+
+      it "should print the not_after date in '%Y-%m-%dT%H:%M:%S%Z' format in the third field" do
+        @cert.not_after.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "after_time"
+
+        @inventory.format(@cert).split[2].should == "after_time"
+      end
+
+      it "should print the subject in the fourth field" do
+        @inventory.format(@cert).split[3].should == "mycert"
+      end
+
+      it "should add a carriage return" do
+        @inventory.format(@cert).should =~ /\n$/
+      end
+
+      it "should produce a line consisting of the serial number, start date, expiration date, and subject" do
+        # Just make sure our serial and subject bracket the lines.
+        @inventory.format(@cert).should =~ /^0x.+mycert$/
+      end
+    end
+
+    it "should be able to find a given host's serial number" do
+      @inventory.should respond_to(:serial)
+    end
+
+    describe "and finding a serial number" do
+      it "should return nil if the inventory file is missing" do
+        FileTest.expects(:exist?).with("/inven/tory").returns false
+        @inventory.serial(:whatever).should be_nil
+      end
+
+      it "should return the serial number from the line matching the provided name" do
+        File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
+
+        @inventory.serial("me").should == 15
+      end
+
+      it "should return the number as an integer" do
+        File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
+
+        @inventory.serial("me").should == 15
+      end
+    end
+  end
+end

data/spec/unit/ssl/key_spec.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/ssl/key'
+
+describe Puppet::SSL::Key do
+  before do
+    @class = Puppet::SSL::Key
+  end
+
+  it "should be extended with the Indirector module" do
+    @class.singleton_class.should be_include(Puppet::Indirector)
+  end
+
+  it "should indirect key" do
+    @class.indirection.name.should == :key
+  end
+
+  it "should default to the :file terminus" do
+    @class.indirection.terminus_class.should == :file
+  end
+
+  it "should only support the text format" do
+    @class.supported_formats.should == [:s]
+  end
+
+  it "should have a method for determining whether it's a CA key" do
+    @class.new("test").should respond_to(:ca?)
+  end
+
+  it "should consider itself a ca key if its name matches the CA_NAME" do
+    @class.new(Puppet::SSL::Host.ca_name).should be_ca
+  end
+
+  describe "when initializing" do
+    it "should set its password file to the :capass if it's a CA key" do
+      Puppet.settings.stubs(:value).returns "whatever"
+      Puppet.settings.stubs(:value).with(:capass).returns "/ca/pass"
+
+      key = Puppet::SSL::Key.new(Puppet::SSL::Host.ca_name)
+      key.password_file.should == "/ca/pass"
+    end
+
+    it "should downcase its name" do
+      @class.new("MyName").name.should == "myname"
+    end
+
+    it "should set its password file to the default password file if it is not the CA key" do
+      Puppet.settings.stubs(:value).returns "whatever"
+      Puppet.settings.stubs(:value).with(:passfile).returns "/normal/pass"
+
+      key = Puppet::SSL::Key.new("notca")
+      key.password_file.should == "/normal/pass"
+    end
+  end
+
+  describe "when managing instances" do
+    before do
+      @key = @class.new("myname")
+    end
+
+    it "should have a name attribute" do
+      @key.name.should == "myname"
+    end
+
+    it "should have a content attribute" do
+      @key.should respond_to(:content)
+    end
+
+    it "should be able to read keys from disk" do
+      path = "/my/path"
+      File.expects(:read).with(path).returns("my key")
+      key = mock 'key'
+      OpenSSL::PKey::RSA.expects(:new).returns(key)
+      @key.read(path).should equal(key)
+      @key.content.should equal(key)
+    end
+
+    it "should not try to use the provided password file if the file does not exist" do
+      FileTest.stubs(:exist?).returns false
+      @key.password_file = "/path/to/password"
+
+      path = "/my/path"
+
+      File.stubs(:read).with(path).returns("my key")
+      OpenSSL::PKey::RSA.expects(:new).with("my key", nil).returns(mock('key'))
+      File.expects(:read).with("/path/to/password").never
+
+      @key.read(path)
+    end
+
+    it "should read the key with the password retrieved from the password file if one is provided" do
+      FileTest.stubs(:exist?).returns true
+      @key.password_file = "/path/to/password"
+
+      path = "/my/path"
+      File.expects(:read).with(path).returns("my key")
+      File.expects(:read).with("/path/to/password").returns("my password")
+
+      key = mock 'key'
+      OpenSSL::PKey::RSA.expects(:new).with("my key", "my password").returns(key)
+      @key.read(path).should equal(key)
+      @key.content.should equal(key)
+    end
+
+    it "should return an empty string when converted to a string with no key" do
+      @key.to_s.should == ""
+    end
+
+    it "should convert the key to pem format when converted to a string" do
+      key = mock 'key', :to_pem => "pem"
+      @key.content = key
+      @key.to_s.should == "pem"
+    end
+
+    it "should have a :to_text method that it delegates to the actual key" do
+      real_key = mock 'key'
+      real_key.expects(:to_text).returns "keytext"
+      @key.content = real_key
+      @key.to_text.should == "keytext"
+    end
+  end
+
+  describe "when generating the private key" do
+    before do
+      @instance = @class.new("test")
+
+      @key = mock 'key'
+    end
+
+    it "should create an instance of OpenSSL::PKey::RSA" do
+      OpenSSL::PKey::RSA.expects(:new).returns(@key)
+
+      @instance.generate
+    end
+
+    it "should create the private key with the keylength specified in the settings" do
+      Puppet.settings.expects(:value).with(:keylength).returns("50")
+      OpenSSL::PKey::RSA.expects(:new).with(50).returns(@key)
+
+      @instance.generate
+    end
+
+    it "should set the content to the generated key" do
+      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
+      @instance.generate
+      @instance.content.should equal(@key)
+    end
+
+    it "should return the generated key" do
+      OpenSSL::PKey::RSA.stubs(:new).returns(@key)
+      @instance.generate.should equal(@key)
+    end
+
+    it "should return the key in pem format" do
+      @instance.generate
+      @instance.content.expects(:to_pem).returns "my normal key"
+      @instance.to_s.should == "my normal key"
+    end
+
+    describe "with a password file set" do
+      it "should return a nil password if the password file does not exist" do
+        FileTest.expects(:exist?).with("/path/to/pass").returns false
+        File.expects(:read).with("/path/to/pass").never
+
+        @instance.password_file = "/path/to/pass"
+
+        @instance.password.should be_nil
+      end
+
+      it "should return the contents of the password file as its password" do
+        FileTest.expects(:exist?).with("/path/to/pass").returns true
+        File.expects(:read).with("/path/to/pass").returns "my password"
+
+        @instance.password_file = "/path/to/pass"
+
+        @instance.password.should == "my password"
+      end
+
+      it "should export the private key to text using the password" do
+        Puppet.settings.stubs(:value).with(:keylength).returns("50")
+
+        @instance.password_file = "/path/to/pass"
+        @instance.stubs(:password).returns "my password"
+
+        OpenSSL::PKey::RSA.expects(:new).returns(@key)
+        @instance.generate
+
+        cipher = mock 'cipher'
+        OpenSSL::Cipher::DES.expects(:new).with(:EDE3, :CBC).returns cipher
+        @key.expects(:export).with(cipher, "my password").returns "my encrypted key"
+
+        @instance.to_s.should == "my encrypted key"
+      end
+    end
+  end
+end

data/spec/unit/status_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Puppet::Status do
+  it "should implement find" do
+    Puppet::Status.find( :default ).should be_is_a(Puppet::Status)
+    Puppet::Status.find( :default ).status["is_alive"].should == true
+  end
+
+  it "should default to is_alive is true" do
+    Puppet::Status.new.status["is_alive"].should == true
+  end
+
+  it "should return a pson hash" do
+    Puppet::Status.new.status.to_pson.should == '{"is_alive":true}'
+  end
+
+  it "should accept a hash from pson" do
+    status = Puppet::Status.new( { "is_alive" => false } )
+    status.status.should == { "is_alive" => false }
+  end
+
+  it "should have a name" do
+    Puppet::Status.new.name
+  end
+
+  it "should allow a name to be set" do
+    Puppet::Status.new.name = "status"
+  end
+end

data/spec/unit/transaction/change_spec.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/transaction/change'
+
+describe Puppet::Transaction::Change do
+  Change = Puppet::Transaction::Change
+
+  describe "when initializing" do
+    before do
+      @property = stub 'property', :path => "/property/path", :should => "shouldval"
+    end
+
+    it "should require the property and current value" do
+      lambda { Change.new }.should raise_error
+    end
+
+    it "should set its property to the provided property" do
+      Change.new(@property, "value").property.should == :property
+    end
+
+    it "should set its 'is' value to the provided value" do
+      Change.new(@property, "value").is.should == "value"
+    end
+
+    it "should retrieve the 'should' value from the property" do
+      # Yay rspec :)
+      Change.new(@property, "value").should.should == @property.should
+    end
+  end
+
+  describe "when an instance" do
+    before do
+      @property = stub 'property', :path => "/property/path", :should => "shouldval"
+      @change = Change.new(@property, "value")
+    end
+
+    it "should be noop if the property is noop" do
+      @property.expects(:noop).returns true
+      @change.noop?.should be_true
+    end
+
+    it "should be auditing if set so" do
+      @change.auditing = true
+      @change.must be_auditing
+    end
+
+    it "should set its resource to the proxy if it has one" do
+      @change.proxy = :myresource
+      @change.resource.should == :myresource
+    end
+
+    it "should set its resource to the property's resource if no proxy is set" do
+      @property.expects(:resource).returns :myresource
+      @change.resource.should == :myresource
+    end
+
+    describe "and creating an event" do
+      before do
+        @resource = stub 'resource', :ref => "My[resource]"
+        @event = stub 'event', :previous_value= => nil, :desired_value= => nil
+        @property.stubs(:event).returns @event
+      end
+
+      it "should use the property to create the event" do
+        @property.expects(:event).returns @event
+        @change.event.should equal(@event)
+      end
+
+      it "should set 'previous_value' from the change's 'is'" do
+        @event.expects(:previous_value=).with(@change.is)
+        @change.event
+      end
+
+      it "should set 'desired_value' from the change's 'should'" do
+        @event.expects(:desired_value=).with(@change.should)
+        @change.event
+      end
+    end
+
+    describe "and executing" do
+      before do
+        @event = Puppet::Transaction::Event.new(:myevent)
+        @event.stubs(:send_log)
+        @change.stubs(:noop?).returns false
+        @property.stubs(:event).returns @event
+
+        @property.stub_everything
+        @property.stubs(:resource).returns "myresource"
+        @property.stubs(:name).returns :myprop
+      end
+
+      describe "in noop mode" do
+        before { @change.stubs(:noop?).returns true }
+
+        it "should log that it is in noop" do
+          @property.expects(:is_to_s)
+          @property.expects(:should_to_s)
+
+          @event.expects(:message=).with { |msg| msg.include?("should be") }
+
+          @change.apply
+        end
+
+        it "should produce a :noop event and return" do
+          @property.stub_everything
+
+          @event.expects(:status=).with("noop")
+
+          @change.apply.should == @event
+        end
+      end
+
+      describe "in audit mode" do
+        before { @change.auditing = true }
+
+        it "should log that it is in audit mode" do
+          @property.expects(:is_to_s)
+          @property.expects(:should_to_s)
+
+          @event.expects(:message=).with { |msg| msg.include?("audit") }
+
+          @change.apply
+        end
+
+        it "should produce a :audit event and return" do
+          @property.stub_everything
+
+          @event.expects(:status=).with("audit")
+
+          @change.apply.should == @event
+        end
+      end
+
+      it "should sync the property" do
+        @property.expects(:sync)
+
+        @change.apply
+      end
+
+      it "should return the default event if syncing the property returns nil" do
+        @property.stubs(:sync).returns nil
+
+        @change.expects(:event).with(nil).returns @event
+
+        @change.apply.should == @event
+      end
+
+      it "should return the default event if syncing the property returns an empty array" do
+        @property.stubs(:sync).returns []
+
+        @change.expects(:event).with(nil).returns @event
+
+        @change.apply.should == @event
+      end
+
+      it "should log the change" do
+        @property.expects(:sync).returns [:one]
+
+        @event.expects(:send_log)
+
+        @change.apply
+      end
+
+      it "should set the event's message to the change log" do
+        @property.expects(:change_to_s).returns "my change"
+        @change.apply.message.should == "my change"
+      end
+
+      it "should set the event's status to 'success'" do
+        @change.apply.status.should == "success"
+      end
+
+      describe "and the change fails" do
+        before { @property.expects(:sync).raises "an exception" }
+
+        it "should catch the exception and log the err" do
+          @event.expects(:send_log)
+          lambda { @change.apply }.should_not raise_error
+        end
+
+        it "should mark the event status as 'failure'" do
+          @change.apply.status.should == "failure"
+        end
+
+        it "should set the event log to a failure log" do
+          @change.apply.message.should be_include("failed")
+        end
+      end
+    end
+  end
+end