puppet 3.0.0.rc5 → 3.0.0.rc7

data/spec/unit/provider/package/pkg_spec.rb

@@ -56,10 +56,11 @@ describe Puppet::Type.type(:package).provider(:pkg) do
       {
         'spkg       0.0.7  i--' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg},
         'spkg (me)  0.0.7  i--' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg, :publisher => 'me'},
+        'spkg (me)  0.0.7  if-' => {:name => 'spkg', :ensure => 'held', :status => 'installed', :provider => :pkg, :publisher => 'me'},
         'spkg       0.0.7  installed -----' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg},
-        'spkg (me)  0.0.7  installed' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg, :publisher => 'me'},
+        'spkg (me)  0.0.7  installed -----' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg, :publisher => 'me'},
        }.each do |k, v|
-        it "should correctly parse" do
+        it "[#{k}] should correctly parse" do
           described_class.parse_line(k).should == v
         end
       end
@@ -172,6 +173,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
     context ":install" do
       it "should accept all licenses" do
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.install
       end
@@ -180,12 +182,14 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         # Should install also check if the version installed is the same version we are asked to install? or should we rely on puppet for that?
         resource[:ensure] = '0.0.7'
         $CHILD_STATUS.stubs(:exitstatus).returns 0
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns 'dummy       0.0.6  installed -----'
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
         provider.install
       end
       it "should install specific version(2)" do
         resource[:ensure] = '0.0.8'
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns 'dummy       0.0.7  installed -----'
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.8'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
@@ -196,12 +200,22 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         provider.expects(:query).with().returns({:ensure => '0.0.8'})
         provider.expects(:uninstall).with()
         $CHILD_STATUS.stubs(:exitstatus).returns 0
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
         provider.install
       end
       it "should install any if version is not specified" do
         resource[:ensure] = :present
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.install
+      end
+      it "should install if no version was previously installed, and a specific version was requested" do
+        resource[:ensure] = '0.0.7'
+        provider.expects(:query).with().returns({:ensure => :absent})
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.install
       end

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

@@ -54,8 +54,8 @@ describe provider_class, :as_platform => :posix do
     end
   end
 
-  it "(#15797) should use 'reset' instead of 'on' when calling enable" do
-    provider_class.expects(:chkconfig).with(@resource[:name], :reset)
+  it "(#15797) should use 'on' when calling enable" do
+    provider_class.expects(:chkconfig).with(@resource[:name], :on)
     @provider.enable
   end
 

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

@@ -8,6 +8,10 @@ describe "sshkey parsed provider" do
   let :provider do type.provider(:parsed) end
   subject { provider }
 
+  after :each do
+    subject.clear
+  end
+
   def key
     'AAAAB3NzaC1yc2EAAAABIwAAAQEAzwHhxXvIrtfIwrudFqc8yQcIfMudrgpnuh1F3AV6d2BrLgu/yQE7W5UyJMUjfj427sQudRwKW45O0Jsnr33F4mUw+GIMlAAmp9g24/OcrTiB8ZUKIjoPy/cO4coxGi8/NECtRzpD/ZUPFh6OEpyOwJPMb7/EC2Az6Otw4StHdXUYw22zHazBcPFnv6zCgPx1hA7QlQDWTu4YcL0WmTYQCtMUb3FUqrcFtzGDD0ytosgwSd+JyN5vj5UwIABjnNOHPZ62EY1OFixnfqX/+dUwrFSs5tPgBF/KkC6R7tmbUfnBON6RrGEmu+ajOTOLy23qUZB4CQ53V7nyAWhzqSK+hw=='
   end

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

@@ -2,257 +2,256 @@ require 'spec_helper'
 require 'puppet_spec/files'
 require 'tempfile'
 
-provider_class = Puppet::Type.type(:user).provider(:user_role_add)
-
-describe provider_class, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:user).provider(:user_role_add), :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
+  let(:resource) { Puppet::Type.type(:user).new(:name => 'myuser', :managehome => false, :allowdupe => false) }
+  let(:provider) { described_class.new(resource) }
 
   before do
-    @resource = stub("resource", :name => "myuser", :managehome? => nil)
-
-    @resource.stubs(:should).returns "fakeval"
-    @resource.stubs(:should).with(:keys).returns Hash.new
-    @resource.stubs(:[]).returns "fakeval"
-
-    @resource.stubs(:allowdupe?).returns false
-    @provider = provider_class.new(@resource)
+    resource.stubs(:should).returns "fakeval"
+    resource.stubs(:should).with(:keys).returns Hash.new
+    resource.stubs(:[]).returns "fakeval"
   end
 
-  describe "when calling command" do
+
+  describe "#command" do
     before do
       klass = stub("provider")
       klass.stubs(:command).with(:foo).returns("userfoo")
       klass.stubs(:command).with(:role_foo).returns("rolefoo")
-      @provider.stubs(:class).returns(klass)
+      provider.stubs(:class).returns(klass)
     end
 
     it "should use the command if not a role and ensure!=role" do
-      @provider.stubs(:is_role?).returns(false)
-      @provider.stubs(:exists?).returns(false)
-      @resource.stubs(:[]).with(:ensure).returns(:present)
-      @provider.command(:foo).should == "userfoo"
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:present)
+      provider.class.stubs(:foo)
+      provider.command(:foo).should == "userfoo"
     end
 
     it "should use the role command when a role" do
-      @provider.stubs(:is_role?).returns(true)
-      @provider.command(:foo).should == "rolefoo"
+      provider.stubs(:is_role?).returns(true)
+      provider.command(:foo).should == "rolefoo"
     end
 
     it "should use the role command when !exists and ensure=role" do
-      @provider.stubs(:is_role?).returns(false)
-      @provider.stubs(:exists?).returns(false)
-      @resource.stubs(:[]).with(:ensure).returns(:role)
-      @provider.command(:foo).should == "rolefoo"
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:exists?).returns(false)
+      resource.stubs(:[]).with(:ensure).returns(:role)
+      provider.command(:foo).should == "rolefoo"
     end
   end
 
-  describe "when calling transition" do
+  describe "#transition" do
     it "should return the type set to whatever is passed in" do
-      @provider.expects(:command).with(:modify).returns("foomod")
-      @provider.transition("bar").include?("type=bar")
+      provider.expects(:command).with(:modify).returns("foomod")
+      provider.transition("bar").include?("type=bar")
     end
   end
 
-  describe "when calling create" do
+  describe "#create" do
     before do
-      @provider.stubs(:password=)
+      provider.stubs(:password=)
     end
 
     it "should use the add command when the user is not a role" do
-      @provider.stubs(:is_role?).returns(false)
-      @provider.expects(:addcmd).returns("useradd")
-      @provider.expects(:run).at_least_once
-      @provider.create
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:addcmd).returns("useradd")
+      provider.expects(:run).at_least_once
+      provider.create
     end
 
     it "should use transition(normal) when the user is a role" do
-      @provider.stubs(:is_role?).returns(true)
-      @provider.expects(:transition).with("normal")
-      @provider.expects(:run)
-      @provider.create
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:transition).with("normal")
+      provider.expects(:run)
+      provider.create
     end
 
     it "should set password age rules" do
-      @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :user_role_add
-      @provider = provider_class.new(@resource)
-      @provider.stubs(:user_attributes)
-      @provider.stubs(:execute)
-      @provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, "myuser"] }
-      @provider.create
+      resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :user_role_add
+      provider = described_class.new(resource)
+      provider.stubs(:user_attributes)
+      provider.stubs(:execute)
+      provider.expects(:execute).with { |cmd, *args| args == ["-n", 5, "-x", 10, "myuser"] }
+      provider.create
     end
   end
 
-  describe "when calling destroy" do
+  describe "#destroy" do
     it "should use the delete command if the user exists and is not a role" do
-      @provider.stubs(:exists?).returns(true)
-      @provider.stubs(:is_role?).returns(false)
-      @provider.expects(:deletecmd)
-      @provider.expects(:run)
-      @provider.destroy
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
+      provider.destroy
     end
 
     it "should use the delete command if the user is a role" do
-      @provider.stubs(:exists?).returns(true)
-      @provider.stubs(:is_role?).returns(true)
-      @provider.expects(:deletecmd)
-      @provider.expects(:run)
-      @provider.destroy
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(true)
+      provider.expects(:deletecmd)
+      provider.expects(:run)
+      provider.destroy
     end
   end
 
-  describe "when calling create_role" do
+  describe "#create_role" do
     it "should use the transition(role) if the user exists" do
-      @provider.stubs(:exists?).returns(true)
-      @provider.stubs(:is_role?).returns(false)
-      @provider.expects(:transition).with("role")
-      @provider.expects(:run)
-      @provider.create_role
+      provider.stubs(:exists?).returns(true)
+      provider.stubs(:is_role?).returns(false)
+      provider.expects(:transition).with("role")
+      provider.expects(:run)
+      provider.create_role
     end
 
     it "should use the add command when role doesn't exists" do
-      @provider.stubs(:exists?).returns(false)
-      @provider.expects(:addcmd)
-      @provider.expects(:run)
-      @provider.create_role
+      provider.stubs(:exists?).returns(false)
+      provider.expects(:addcmd)
+      provider.expects(:run)
+      provider.create_role
     end
   end
 
-  describe "when allow duplicate is enabled" do
+  describe "with :allow_duplicates" do
     before do
-      @resource.expects(:allowdupe?).returns true
-      @resource.stubs(:system?)
-      @provider.stubs(:is_role?).returns(false)
-      @provider.stubs(:execute)
-      @provider.expects(:execute).with { |args| args.include?("-o") }
+      resource.expects(:allowdupe?).returns true
+      provider.stubs(:is_role?).returns(false)
+      provider.stubs(:execute)
+      resource.stubs(:system?).returns false
+      provider.expects(:execute).with { |args| args.include?("-o") }
     end
 
     it "should add -o when the user is being created" do
-      @provider.stubs(:password=)
-      @provider.create
+      provider.stubs(:password=)
+      provider.create
     end
 
     it "should add -o when the uid is being modified" do
-      @provider.uid = 150
+      provider.uid = 150
     end
   end
 
   [:roles, :auths, :profiles].each do |val|
-    describe "when getting #{val}" do
-      it "should get the user_attributes" do
-        @provider.expects(:user_attributes)
-        @provider.send(val)
-      end
-
-      it "should get the #{val} attribute" do
-        attributes = mock("attributes")
-        attributes.expects(:[]).with(val)
-        @provider.stubs(:user_attributes).returns(attributes)
-        @provider.send(val)
+    context "#send" do
+      describe "when getting #{val}" do
+        it "should get the user_attributes" do
+          provider.expects(:user_attributes)
+          provider.send(val)
+        end
+
+        it "should get the #{val} attribute" do
+          attributes = mock("attributes")
+          attributes.expects(:[]).with(val)
+          provider.stubs(:user_attributes).returns(attributes)
+          provider.send(val)
+        end
       end
     end
   end
 
-  describe "when getting the keys" do
+  describe "#keys" do
     it "should get the user_attributes" do
-      @provider.expects(:user_attributes)
-      @provider.keys
+      provider.expects(:user_attributes)
+      provider.keys
     end
 
     it "should call removed_managed_attributes" do
-      @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
-      @provider.expects(:remove_managed_attributes)
-      @provider.keys
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
+      provider.expects(:remove_managed_attributes)
+      provider.keys
     end
 
     it "should removed managed attribute (type, auths, roles, etc)" do
-      @provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
-      @provider.keys.should == { :foo => "something" }
+      provider.stubs(:user_attributes).returns({ :type => "normal", :foo => "something" })
+      provider.keys.should == { :foo => "something" }
     end
   end
 
-  describe "when adding properties" do
+  describe "#add_properties" do
     it "should call build_keys_cmd" do
-      @resource.stubs(:should).returns ""
-      @resource.expects(:should).with(:keys).returns({ :foo => "bar" })
-      @provider.expects(:build_keys_cmd).returns([])
-      @provider.add_properties
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar" })
+      provider.expects(:build_keys_cmd).returns([])
+      provider.add_properties
     end
 
     it "should add the elements of the keys hash to an array" do
-      @resource.stubs(:should).returns ""
-      @resource.expects(:should).with(:keys).returns({ :foo => "bar"})
-      @provider.add_properties.must == ["-K", "foo=bar"]
+      resource.stubs(:should).returns ""
+      resource.expects(:should).with(:keys).returns({ :foo => "bar"})
+      provider.add_properties.must == ["-K", "foo=bar"]
     end
   end
 
-  describe "when calling build_keys_cmd" do
+  describe "#build_keys_cmd" do
     it "should build cmd array with keypairs seperated by -K ending with user" do
-      @provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"}).should.eql? ["-K", "foo=bar", "-K", "baz=boo"]
+      provider.build_keys_cmd({"foo" => "bar", "baz" => "boo"}).should.eql? ["-K", "foo=bar", "-K", "baz=boo"]
     end
   end
 
-  describe "when setting the keys" do
+  describe "#keys=" do
     before do
-      @provider.stubs(:is_role?).returns(false)
+      provider.stubs(:is_role?).returns(false)
     end
 
     it "should run a command" do
-      @provider.expects(:run)
-      @provider.keys=({})
+      provider.expects(:run)
+      provider.keys=({})
     end
 
     it "should build the command" do
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @provider.stubs(:command).returns("usermod")
-      @provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
-      @provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
-      @provider.keys=({})
+      resource.stubs(:[]).with(:name).returns("someuser")
+      provider.stubs(:command).returns("usermod")
+      provider.expects(:build_keys_cmd).returns(["-K", "foo=bar"])
+      provider.expects(:run).with(["usermod", "-K", "foo=bar", "someuser"], "modify attribute key pairs")
+      provider.keys=({})
     end
   end
 
-  describe "when getting the hashed password" do
+  describe "#password" do
     before do
       @array = mock "array"
     end
 
     it "should readlines of /etc/shadow" do
       File.expects(:readlines).with("/etc/shadow").returns([])
-      @provider.password
+      provider.password
     end
 
     it "should reject anything that doesn't start with alpha numerics" do
       @array.expects(:reject).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
-      @provider.password
+      provider.password
     end
 
     it "should collect splitting on ':'" do
       @array.stubs(:reject).returns(@array)
       @array.expects(:collect).returns([])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
-      @provider.password
+      provider.password
     end
 
     it "should find the matching user" do
-      @resource.stubs(:[]).with(:name).returns("username")
+      resource.stubs(:[]).with(:name).returns("username")
       @array.stubs(:reject).returns(@array)
       @array.stubs(:collect).returns([["username", "hashedpassword"], ["someoneelse", "theirpassword"]])
       File.stubs(:readlines).with("/etc/shadow").returns(@array)
-      @provider.password.must == "hashedpassword"
+      provider.password.must == "hashedpassword"
     end
 
     it "should get the right password" do
-      @resource.stubs(:[]).with(:name).returns("username")
+      resource.stubs(:[]).with(:name).returns("username")
       File.stubs(:readlines).with("/etc/shadow").returns(["#comment", "   nonsense", "  ", "username:hashedpassword:stuff:foo:bar:::", "other:pword:yay:::"])
-      @provider.password.must == "hashedpassword"
+      provider.password.must == "hashedpassword"
     end
   end
 
-  describe "when setting the password" do
+  describe "#password=" do
     let(:path) { tmpfile('etc-shadow') }
 
     before :each do
-      @provider.stubs(:target_file_path).returns(path)
+      provider.stubs(:target_file_path).returns(path)
     end
 
     def write_fixture(content)
@@ -263,7 +262,7 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
       write_fixture <<FIXTURE
 fakeval:seriously:15315:0:99999:7:::
 FIXTURE
-      @provider.password = "totally"
+      provider.password = "totally"
       File.read(path).should =~ /^fakeval:totally:/
     end
 
@@ -274,7 +273,7 @@ fakeval:seriously:15315:0:99999:7:::
 fakevalish:seriously:15315:0:99999:7:::
 after:seriously:15315:0:99999:7:::
 FIXTURE
-      @provider.password = "totally"
+      provider.password = "totally"
       File.read(path).should == <<EOT
 before:seriously:15315:0:99999:7:::
 fakeval:totally:15315:0:99999:7:::
@@ -292,7 +291,7 @@ after:seriously:15315:0:99999:7:::
 FIXTURE
 
       write_fixture fixture
-      @provider.password = "totally"
+      provider.password = "totally"
       File.read(path).should == fixture
     end
   end
@@ -300,19 +299,19 @@ FIXTURE
   describe "#shadow_entry" do
     it "should return the line for the right user" do
       File.stubs(:readlines).returns(["someuser:!:10:5:20:7:1::\n", "fakeval:*:20:10:30:7:2::\n", "testuser:*:30:15:40:7:3::\n"])
-      @provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2"]
+      provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2"]
     end
   end
 
   describe "#password_max_age" do
     it "should return a maximum age number" do
       File.stubs(:readlines).returns(["fakeval:NP:12345:0:50::::\n"])
-      @provider.password_max_age.should == "50"
+      provider.password_max_age.should == "50"
     end
 
     it "should return -1 for no maximum" do
       File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
-      @provider.password_max_age.should == -1
+      provider.password_max_age.should == -1
     end
   end
 end