puppet 2.7.8 → 2.7.9

data/spec/unit/network/http/api/v1_spec.rb

@@ -123,6 +123,10 @@ describe Puppet::Network::HTTP::API::V1 do
       @tester.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
     end
 
+    it "should change indirection name to 'probe' if the http method is a GET and the indirection name is probes" do
+      @tester.uri2indirection("GET", "/env/probes/bar", {})[0].should == 'probe'
+    end
+
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
       @tester.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
     end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -20,8 +20,9 @@ describe 'function for dynamically creating resources' do
   it "should exist" do
     Puppet::Parser::Functions.function(:create_resources).should == "function_create_resources"
   end
-  it 'should require two arguments' do
-    lambda { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2)')
+  it 'should require two or three arguments' do
+    lambda { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
+    lambda { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
   describe 'when creating native types' do
     before :each do
@@ -58,6 +59,11 @@ describe 'function for dynamically creating resources' do
       foo.should be
       rg.path_between(test,foo).should be
     end
+    it 'should account for default values' do
+      @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'}])
+      @compiler.catalog.resource(:file, "/etc/foo")['group'].should == 'bar'
+      @compiler.catalog.resource(:file, "/etc/baz")['group'].should == 'food'
+    end
   end
   describe 'when dynamically creating resource types' do
     before :each do 
@@ -103,6 +109,11 @@ notify{test:}
       rg.path_between(test,blah).should be
       @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
     end
+    it 'should account for default values' do
+      @scope.function_create_resources(['foo', {'blah'=>{}}, {'one' => 'two'}])
+      @scope.compiler.compile
+      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+    end
   end
   describe 'when creating classes' do
     before :each do
@@ -114,7 +125,7 @@ notify{tester:}
       @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
       Puppet::Parser::Functions.function(:create_resources)
     end
-    it 'should be able to create classes', :'fails_on_ruby_1.9.2' => true do
+    it 'should be able to create classes' do
       @scope.function_create_resources(['class', {'bar'=>{'one'=>'two'}}])
       @scope.compiler.compile
       @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
@@ -123,7 +134,7 @@ notify{tester:}
     it 'should fail to create non-existing classes' do
       lambda { @scope.function_create_resources(['class', {'blah'=>{'one'=>'two'}}]) }.should raise_error(ArgumentError ,'could not find hostclass blah')
     end
-    it 'should be able to add edges', :'fails_on_ruby_1.9.2' => true do
+    it 'should be able to add edges' do
       @scope.function_create_resources(['class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}}])
       @scope.compiler.compile
       rg = @scope.compiler.catalog.to_ral.relationship_graph
@@ -133,5 +144,11 @@ notify{tester:}
       tester.should be
       rg.path_between(tester,test).should be
     end
+    it 'should account for default values' do
+      @scope.function_create_resources(['class', {'bar'=>{}}, {'one' => 'two'}])
+      @scope.compiler.compile
+      @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
+      @compiler.catalog.resource(:class, "bar").should_not be_nil#['message'].should == 'two'
+    end
   end
 end

data/spec/unit/rails_spec.rb

@@ -88,169 +88,100 @@ describe Puppet::Rails, "when initializing a sqlite3 connection", :if => Puppet.
   end
 end
 
-describe Puppet::Rails, "when initializing a mysql connection", :if => Puppet.features.rails? do
-  it "should provide the adapter, log_level, and host, port, username, password, database, and reconnect arguments" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 45).to_s)
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("")
-
-    Puppet::Rails.database_arguments.should == {
-      :adapter => "mysql",
-      :log_level => "testlevel",
-      :host => "testserver",
-      :username => "testuser",
-      :password => "testpassword",
-      :pool => pool_size,
-      :database => "testname",
-      :reconnect => true
-    }
-  end
-
-  it "should provide the adapter, log_level, and host, port, username, password, database, socket, connections, and reconnect arguments" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 12).to_s)
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
-
-    Puppet::Rails.database_arguments.should == {
-      :adapter => "mysql",
-      :log_level => "testlevel",
-      :host => "testserver",
-      :port => "9999",
-      :username => "testuser",
-      :password => "testpassword",
-      :pool => pool_size,
-      :database => "testname",
-      :socket => "testsocket",
-      :reconnect => true
-    }
-  end
-
-  it "should provide the adapter, log_level, and host, port, username, password, database, socket, and connections arguments" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 23).to_s)
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
-
-    Puppet::Rails.database_arguments.should == {
-      :adapter => "mysql",
-      :log_level => "testlevel",
-      :host => "testserver",
-      :port => "9999",
-      :username => "testuser",
-      :password => "testpassword",
-      :pool => pool_size,
-      :database => "testname",
-      :socket => "testsocket",
-      :reconnect => true
-    }
-  end
-
-  it "should not provide the pool if dbconnections is 0, '0', or ''" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
-
-    Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
-
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
-
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('')
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
-  end
-end
-
-describe Puppet::Rails, "when initializing a postgresql connection", :if => Puppet.features.rails? do
-  it "should provide the adapter, log_level, and host, port, username, password, connections, and database arguments" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 200).to_s)
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("")
-
-    Puppet::Rails.database_arguments.should == {
-      :adapter => "postgresql",
-      :log_level => "testlevel",
-      :host => "testserver",
-      :port => "9999",
-      :username => "testuser",
-      :password => "testpassword",
-      :pool => pool_size,
-      :database => "testname",
-      :reconnect => true
-    }
-  end
+['mysql','mysql2','postgresql'].each do |dbadapter|
+  describe Puppet::Rails, "when initializing a #{dbadapter} connection", :if => Puppet.features.rails? do
+    it "should provide the adapter, log_level, and host, port, username, password, database, and reconnect arguments" do
+      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
+      Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
+      Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+      Puppet.settings.stubs(:value).with(:dbport).returns("")
+      Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+      Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
+      Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 45).to_s)
+      Puppet.settings.stubs(:value).with(:dbname).returns("testname")
+      Puppet.settings.stubs(:value).with(:dbsocket).returns("")
+
+      Puppet::Rails.database_arguments.should == {
+        :adapter => dbadapter,
+        :log_level => "testlevel",
+        :host => "testserver",
+        :username => "testuser",
+        :password => "testpassword",
+        :pool => pool_size,
+        :database => "testname",
+        :reconnect => true
+      }
+    end
 
-  it "should provide the adapter, log_level, and host, port, username, password, database, connections, and socket arguments" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("postgresql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 122).to_s)
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
+    it "should provide the adapter, log_level, and host, port, username, password, database, socket, connections, and reconnect arguments" do
+      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
+      Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
+      Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+      Puppet.settings.stubs(:value).with(:dbport).returns("9999")
+      Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+      Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
+      Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 12).to_s)
+      Puppet.settings.stubs(:value).with(:dbname).returns("testname")
+      Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
+
+      Puppet::Rails.database_arguments.should == {
+        :adapter => dbadapter,
+        :log_level => "testlevel",
+        :host => "testserver",
+        :port => "9999",
+        :username => "testuser",
+        :password => "testpassword",
+        :pool => pool_size,
+        :database => "testname",
+        :socket => "testsocket",
+        :reconnect => true
+      }
+    end
 
-    Puppet::Rails.database_arguments.should == {
-      :adapter => "postgresql",
-      :log_level => "testlevel",
-      :host => "testserver",
-      :port => "9999",
-      :username => "testuser",
-      :password => "testpassword",
-      :pool => pool_size,
-      :database => "testname",
-      :socket => "testsocket",
-      :reconnect => true
-    }
-  end
+    it "should provide the adapter, log_level, and host, port, username, password, database, socket, and connections arguments" do
+      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
+      Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
+      Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+      Puppet.settings.stubs(:value).with(:dbport).returns("9999")
+      Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+      Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
+      Puppet.settings.stubs(:value).with(:dbconnections).returns((pool_size = 23).to_s)
+      Puppet.settings.stubs(:value).with(:dbname).returns("testname")
+      Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
+
+      Puppet::Rails.database_arguments.should == {
+        :adapter => dbadapter,
+        :log_level => "testlevel",
+        :host => "testserver",
+        :port => "9999",
+        :username => "testuser",
+        :password => "testpassword",
+        :pool => pool_size,
+        :database => "testname",
+        :socket => "testsocket",
+        :reconnect => true
+      }
+    end
 
-  it "should not provide the pool if dbconnections is 0, '0', or ''" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
-    Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
-    Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
-    Puppet.settings.stubs(:value).with(:dbport).returns("9999")
-    Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
-    Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
-    Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
+    it "should not provide the pool if dbconnections is 0, '0', or ''" do
+      Puppet.settings.stubs(:value).with(:dbadapter).returns(dbadapter)
+      Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
+      Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+      Puppet.settings.stubs(:value).with(:dbport).returns("9999")
+      Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+      Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
+      Puppet.settings.stubs(:value).with(:dbname).returns("testname")
+      Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
 
-    Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
+      Puppet.settings.stubs(:value).with(:dbconnections).returns(0)
+      Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
+      Puppet.settings.stubs(:value).with(:dbconnections).returns('0')
+      Puppet::Rails.database_arguments.should_not be_include(:pool)
 
-    Puppet.settings.stubs(:value).with(:dbconnections).returns('')
-    Puppet::Rails.database_arguments.should_not be_include(:pool)
+      Puppet.settings.stubs(:value).with(:dbconnections).returns('')
+      Puppet::Rails.database_arguments.should_not be_include(:pool)
+    end
   end
 end
 
@@ -292,7 +223,7 @@ describe Puppet::Rails, "when initializing an Oracle connection", :if => Puppet.
   end
 
   it "should not provide the pool if dbconnections is 0, '0', or ''" do
-    Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
+    Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
     Puppet.settings.stubs(:value).with(:dbport).returns("9999")

data/spec/unit/ssl/host_spec.rb

@@ -182,57 +182,48 @@ describe Puppet::SSL::Host do
   it "should cache the localhost instance" do
     host = stub 'host', :certificate => "eh", :key => 'foo'
     Puppet::SSL::Host.expects(:new).once.returns host
-
     Puppet::SSL::Host.localhost.should == Puppet::SSL::Host.localhost
   end
 
   it "should be able to verify its certificate matches its key" do
-    Puppet::SSL::Host.new("foo").should respond_to(:certificate_matches_key?)
+    Puppet::SSL::Host.new("foo").should respond_to(:validate_certificate_with_key)
   end
 
   it "should consider the certificate invalid if it cannot find a key" do
     host = Puppet::SSL::Host.new("foo")
+    certificate = mock('cert', :fingerprint => 'DEADBEEF')
+    host.expects(:certificate).twice.returns certificate
     host.expects(:key).returns nil
-
-    host.should_not be_certificate_matches_key
+    lambda { host.validate_certificate_with_key }.should raise_error(Puppet::Error, "No private key with which to validate certificate with fingerprint: DEADBEEF")
   end
 
   it "should consider the certificate invalid if it cannot find a certificate" do
     host = Puppet::SSL::Host.new("foo")
-    host.expects(:key).returns mock("key")
+    host.expects(:key).never
     host.expects(:certificate).returns nil
-
-    host.should_not be_certificate_matches_key
+    lambda { host.validate_certificate_with_key }.should raise_error(Puppet::Error, "No certificate to validate.")
   end
 
   it "should consider the certificate invalid if the SSL certificate's key verification fails" do
     host = Puppet::SSL::Host.new("foo")
-
     key = mock 'key', :content => "private_key"
     sslcert = mock 'sslcert'
-    certificate = mock 'cert', :content => sslcert
-
+    certificate = mock 'cert', {:content => sslcert, :fingerprint => 'DEADBEEF'}
     host.stubs(:key).returns key
     host.stubs(:certificate).returns certificate
-
     sslcert.expects(:check_private_key).with("private_key").returns false
-
-    host.should_not be_certificate_matches_key
+    lambda { host.validate_certificate_with_key }.should raise_error(Puppet::Error, /DEADBEEF/)
   end
 
   it "should consider the certificate valid if the SSL certificate's key verification succeeds" do
     host = Puppet::SSL::Host.new("foo")
-
     key = mock 'key', :content => "private_key"
     sslcert = mock 'sslcert'
     certificate = mock 'cert', :content => sslcert
-
     host.stubs(:key).returns key
     host.stubs(:certificate).returns certificate
-
     sslcert.expects(:check_private_key).with("private_key").returns true
-
-    host.should be_certificate_matches_key
+    lambda{ host.validate_certificate_with_key }.should_not raise_error
   end
 
   describe "when specifying the CA location" do
@@ -511,15 +502,13 @@ describe Puppet::SSL::Host do
     before do
       @realcert = mock 'certificate'
       @cert = stub 'cert', :content => @realcert
-
       @host.stubs(:key).returns mock("key")
-      @host.stubs(:certificate_matches_key?).returns true
+      @host.stubs(:validate_certificate_with_key)
     end
 
     it "should find the CA certificate if it does not have a certificate" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.stubs(:find).with("myname").returns @cert
-
       @host.certificate
     end
 
@@ -541,34 +530,22 @@ describe Puppet::SSL::Host do
     it "should find the key if it does not have one" do
       Puppet::SSL::Certificate.indirection.stubs(:find)
       @host.expects(:key).returns mock("key")
-
       @host.certificate
     end
 
     it "should generate the key if one cannot be found" do
       Puppet::SSL::Certificate.indirection.stubs(:find)
-
       @host.expects(:key).returns nil
       @host.expects(:generate_key)
-
       @host.certificate
     end
 
     it "should find the certificate in the Certificate class and return the Puppet certificate instance" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns @cert
-
       @host.certificate.should equal(@cert)
     end
 
-    it "should fail if the found certificate does not match the private key" do
-      @host.expects(:certificate_matches_key?).returns false
-
-      Puppet::SSL::Certificate.indirection.stubs(:find).returns @cert
-
-      lambda { @host.certificate }.should raise_error(Puppet::Error)
-    end
-
     it "should return any previously found certificate" do
       Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns(@cert).once