puppet 2.6.2 → 2.6.3

data/spec/unit/parser/compiler_spec.rb

@@ -580,7 +580,7 @@ describe Puppet::Parser::Compiler do
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
-      @class.expects(:mk_plain_resource).with(@scope)
+      @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
@@ -591,7 +591,7 @@ describe Puppet::Parser::Compiler do
 
       @resource.expects(:evaluate).never
 
-      @class.expects(:mk_plain_resource).returns(@resource)
+      @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
@@ -601,7 +601,7 @@ describe Puppet::Parser::Compiler do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
-      @class.expects(:mk_plain_resource).returns(@resource)
+      @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
@@ -638,7 +638,7 @@ describe Puppet::Parser::Compiler do
       @scope.stubs(:class_scope).with(@class)
 
       Puppet::Parser::Resource.stubs(:new).returns(@resource)
-      @class.stubs :mk_plain_resource
+      @class.stubs :ensure_in_catalog
       @compiler.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
     end
   end
@@ -678,7 +678,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
@@ -688,7 +688,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
@@ -698,7 +698,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
@@ -707,7 +707,7 @@ describe Puppet::Parser::Compiler do
 
     it "should set the node's scope as the top scope" do
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
-      node_class = stub 'node', :name => "c", :mk_plain_resource => node_resource
+      node_class = stub 'node', :name => "c", :ensure_in_catalog => node_resource
 
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 

data/spec/unit/parser/lexer_spec.rb

@@ -424,6 +424,7 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
+    %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],

data/spec/unit/parser/parser_spec.rb

@@ -269,16 +269,23 @@ describe Puppet::Parser do
 
     it "should prefer provided options over AST context" do
       @class.expects(:new).with { |opts| opts[:file] == "/bar" }
-      @parser.expects(:ast_context).returns :file => "/foo"
+      @lexer.expects(:file).returns "/foo"
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should include docs when the AST class uses them" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new)
-      @parser.expects(:ast_context).with(true).returns({})
+      @parser.expects(:ast_context).with{ |a| a[0] == true }.returns({})
       @parser.ast(@class, :file => "/bar")
     end
+
+    it "should get docs from lexer using the correct AST line number" do
+      @class.expects(:use_docs).returns true
+      @class.stubs(:new).with{ |a| a[:doc] == "doc" }
+      @lexer.expects(:getcomment).with(12).returns "doc"
+      @parser.ast(@class, :file => "/bar", :line => 12)
+    end
   end
 
   describe "when creating a node" do

data/spec/unit/provider/confine/exists_spec.rb

@@ -39,25 +39,18 @@ describe Puppet::Provider::Confine::Exists do
 
   describe "and the confine is for binaries" do
     before { @confine.stubs(:for_binary).returns true }
-    it "should use its 'binary' method to look up the full path of the file" do
-      @confine.expects(:binary).returns nil
+    it "should use its 'which' method to look up the full path of the file" do
+      @confine.expects(:which).returns nil
       @confine.pass?("/my/file")
     end
 
-    it "should return false if no binary can be found" do
-      @confine.expects(:binary).with("/my/file").returns nil
+    it "should return false if no executable can be found" do
+      @confine.expects(:which).with("/my/file").returns nil
       @confine.pass?("/my/file").should be_false
     end
 
-    it "should return true if the binary can be found and the file exists" do
-      @confine.expects(:binary).with("/my/file").returns "/my/file"
-      FileTest.expects(:exist?).with("/my/file").returns true
-      @confine.pass?("/my/file").should be_true
-    end
-
-    it "should return false if the binary can be found but the file does not exist" do
-      @confine.expects(:binary).with("/my/file").returns "/my/file"
-      FileTest.expects(:exist?).with("/my/file").returns true
+    it "should return true if the executable can be found" do
+      @confine.expects(:which).with("/my/file").returns "/my/file"
       @confine.pass?("/my/file").should be_true
     end
   end

data/spec/unit/provider/mount_spec.rb

@@ -113,7 +113,14 @@ describe Puppet::Provider::Mount do
       @mounter.should be_mounted
     end
 
-    it "should match ' on <name>' if the operating system is not Darwin or Solaris" do
+    it "should match '^<name> on' if the operating system is HP-UX" do
+      Facter.stubs(:value).with("operatingsystem").returns("HP-UX")
+      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
+
+      @mounter.should be_mounted
+    end
+
+    it "should match ' on <name>' if the operating system is not Darwin, Solaris, or HP-UX" do
       Facter.stubs(:value).with("operatingsystem").returns("Debian")
       @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on / and stuff\n/dev/other/disk on /var and stuff")
 

data/spec/unit/provider/service/freebsd_spec.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:freebsd)
+
+describe provider_class do
+  before :each do
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
+  end
+
+  it "should correctly parse rcvar for FreeBSD < 7" do
+    @provider.stubs(:execute).returns <<OUTPUT
+# ntpd
+$ntpd_enable=YES
+OUTPUT
+    @provider.rcvar.should == ['# ntpd', 'ntpd_enable=YES']
+  end
+
+  it "should correctly parse rcvar for FreeBSD 7 to 8" do
+    @provider.stubs(:execute).returns <<OUTPUT
+# ntpd
+ntpd_enable=YES
+OUTPUT
+    @provider.rcvar.should == ['# ntpd', 'ntpd_enable=YES']
+  end
+
+  it "should correctly parse rcvar for FreeBSD >= 8.1" do
+    @provider.stubs(:execute).returns <<OUTPUT
+# ntpd
+#
+ntpd_enable="YES"
+#   (default: "")
+OUTPUT
+    @provider.rcvar.should == ['# ntpd', 'ntpd_enable="YES"', '#   (default: "")']
+  end
+
+  it "should find the right rcvar_value for FreeBSD < 7" do
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable=YES'])
+
+    @provider.rcvar_value.should == "YES"
+  end
+
+  it "should find the right rcvar_value for FreeBSD >= 7" do
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
+
+    @provider.rcvar_value.should == "YES"
+  end
+end

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -5,7 +5,6 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet_spec/files'
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
-require 'tmpdir'
 require 'puppettest/fakes'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
@@ -19,7 +18,7 @@ describe provider_class do
   before :each do
     @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
     @provider = @sshauthkey_class.provider(:parsed)
-    @keyfile = File.join(Dir.tmpdir, 'authorized_keys')
+    @keyfile = tmpfile('authorized_keys')
     @provider.any_instance.stubs(:target).returns @keyfile
     @user = 'random_bob'
     Puppet::Util.stubs(:uid).with(@user).returns 12345

data/spec/unit/provider/user/user_role_add_spec.rb

@@ -72,7 +72,7 @@ describe provider_class do
       @provider = provider_class.new(@resource)
       @provider.stubs(:user_attributes)
       @provider.stubs(:execute)
-      @provider.expects(:execute).with { |cmd, *args| args == ["-m", 5, "-M", 10, "myuser"] }
+      @provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, "myuser"] }
       @provider.create
     end
   end

data/spec/unit/provider/user/useradd_spec.rb

@@ -131,4 +131,46 @@ describe provider_class do
       @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", "someuser"]
     end
   end
+
+  describe "when calling passcmd" do
+    before do
+      @resource.stubs(:allowdupe?).returns true
+      @resource.stubs(:managehome?).returns true
+    end
+
+    it "should call command with :pass" do
+      @provider.expects(:command).with(:password)
+      @provider.passcmd
+    end
+
+    it "should return nil if neither min nor max is set" do
+      @resource.stubs(:should).with(:password_min_age).returns nil
+      @resource.stubs(:should).with(:password_max_age).returns nil
+      @provider.passcmd.must == nil
+    end
+
+    it "should return a chage command array with -m <value> and the user name if password_min_age is set" do
+      @provider.stubs(:command).with(:password).returns("chage")
+      @resource.stubs(:[]).with(:name).returns("someuser")
+      @resource.stubs(:should).with(:password_min_age).returns 123
+      @resource.stubs(:should).with(:password_max_age).returns nil
+      @provider.passcmd.must == ['chage','-m',123,'someuser']
+    end
+
+    it "should return a chage command array with -M <value> if password_max_age is set" do
+      @provider.stubs(:command).with(:password).returns("chage")
+      @resource.stubs(:[]).with(:name).returns("someuser")
+      @resource.stubs(:should).with(:password_min_age).returns nil
+      @resource.stubs(:should).with(:password_max_age).returns 999
+      @provider.passcmd.must == ['chage','-M',999,'someuser']
+    end
+
+    it "should return a chage command array with -M <value> -m <value> if both password_min_age and password_max_age are set" do
+      @provider.stubs(:command).with(:password).returns("chage")
+      @resource.stubs(:[]).with(:name).returns("someuser")
+      @resource.stubs(:should).with(:password_min_age).returns 123
+      @resource.stubs(:should).with(:password_max_age).returns 999
+      @provider.passcmd.must == ['chage','-m',123,'-M',999,'someuser']
+    end
+  end
 end

data/spec/unit/rails_spec.rb

@@ -103,9 +103,9 @@ describe Puppet::Rails, "when initializing a mysql connection" do
     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.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
@@ -113,9 +113,9 @@ describe Puppet::Rails, "when initializing a mysql connection" do
       :host => "testserver",
       :username => "testuser",
       :password => "testpassword",
+      :pool => pool_size,
       :database => "testname",
-      :reconnect => true,
-      :pool => 1
+      :reconnect => true
     }
   end
 
@@ -126,9 +126,9 @@ describe Puppet::Rails, "when initializing a mysql connection" do
     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.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
@@ -137,10 +137,10 @@ describe Puppet::Rails, "when initializing a mysql connection" do
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
+      :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
-      :reconnect => true,
-      :pool => 1
+      :reconnect => true
     }
   end
 
@@ -151,9 +151,9 @@ describe Puppet::Rails, "when initializing a mysql connection" do
     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.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "mysql",
@@ -162,12 +162,32 @@ describe Puppet::Rails, "when initializing a mysql connection" do
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
+      :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
-      :reconnect => true,
-      :pool => 1
+      :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" do
@@ -180,9 +200,9 @@ describe Puppet::Rails, "when initializing a postgresql connection" do
     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.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
@@ -191,9 +211,9 @@ describe Puppet::Rails, "when initializing a postgresql connection" do
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
+      :pool => pool_size,
       :database => "testname",
-      :reconnect => true,
-      :pool => 1
+      :reconnect => true
     }
   end
 
@@ -204,9 +224,9 @@ describe Puppet::Rails, "when initializing a postgresql connection" do
     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")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "postgresql",
@@ -215,50 +235,90 @@ describe Puppet::Rails, "when initializing a postgresql connection" do
       :port => "9999",
       :username => "testuser",
       :password => "testpassword",
+      :pool => pool_size,
       :database => "testname",
       :socket => "testsocket",
-      :pool => 1,
       :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 an Oracle connection" do
   confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
-  it "should provide the adapter, log_level, and username, password, dbconnections, and database arguments" do
+  it "should provide the adapter, log_level, and username, password, and database arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     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 = 123).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
-      :database => "testname",
-      :pool => 1
+      :pool => pool_size,
+      :database => "testname"
     }
   end
 
-  it "should provide the adapter, log_level, and host, username, password, database, pool, and socket arguments" do
+  it "should provide the adapter, log_level, and host, username, password, database and socket arguments" do
     Puppet.settings.stubs(:value).with(:dbadapter).returns("oracle_enhanced")
     Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
     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 = 124).to_s)
     Puppet.settings.stubs(:value).with(:dbname).returns("testname")
-    Puppet.settings.stubs(:value).with(:dbconnections).returns(1)
 
     Puppet::Rails.database_arguments.should == {
       :adapter => "oracle_enhanced",
       :log_level => "testlevel",
       :username => "testuser",
       :password => "testpassword",
-      :database => "testname",
-      :pool => 1
+      :pool => pool_size,
+      :database => "testname"
     }
   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