puppet 0.24.9 → 0.25.0

data/spec/unit/type/filebucket.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:filebucket) do
+    describe "when validating attributes" do
+        %w{name server port path}.each do |attr|
+            it "should have a '#{attr}' parameter" do
+                Puppet::Type.type(:filebucket).attrtype(attr.intern).should == :param
+            end
+        end
+
+        it "should have its 'name' attribute set as its namevar" do
+            Puppet::Type.type(:filebucket).namevar.should == :name
+        end
+    end
+
+    it "should use the clientbucketdir as the path by default path" do
+        Puppet.settings[:clientbucketdir] = "/my/bucket"
+        Puppet::Type.type(:filebucket).new(:name => "main")[:path].should == Puppet[:clientbucketdir]
+    end
+
+    it "should use the masterport as the path by default port" do
+        Puppet.settings[:masterport] = 50
+        Puppet::Type.type(:filebucket).new(:name => "main")[:port].should == Puppet[:masterport]
+    end
+
+    it "should use the server as the path by default server" do
+        Puppet.settings[:server] = "myserver"
+        Puppet::Type.type(:filebucket).new(:name => "main")[:server].should == Puppet[:server]
+    end
+
+    it "be local by default" do
+        bucket = Puppet::Type.type(:filebucket).new :name => "main"
+
+        bucket.bucket.should be_local
+    end
+
+    it "not be local if path is false" do
+        bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+
+        bucket.bucket.should_not be_local
+    end
+
+    it "be local if both a path and a server are specified" do
+        bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "puppet", :path => "/my/path"
+
+        bucket.bucket.should be_local
+    end
+
+    describe "when creating the filebucket" do
+        before do
+            @bucket = stub 'bucket', :name= => nil
+        end
+
+        it "should use any provided path" do
+            bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => "/foo/bar"
+            Puppet::Network::Client.client(:Dipper).expects(:new).with(:Path => "/foo/bar").returns @bucket
+            bucket.bucket
+        end
+        it "should use any provided server and port" do
+            bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
+            Puppet::Network::Client.client(:Dipper).expects(:new).with(:Server => "myserv", :Port => "myport").returns @bucket
+            bucket.bucket
+        end
+
+        it "should use the default server if the path is unset and no server is provided" do
+            Puppet.settings[:server] = "myserv"
+            bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
+            Puppet::Network::Client.client(:Dipper).expects(:new).with { |args| args[:Server] == "myserv" }.returns @bucket
+            bucket.bucket
+        end
+    end
+end

data/spec/unit/type/group.rb

@@ -10,10 +10,6 @@ describe Puppet::Type.type(:group) do
         @class = Puppet::Type.type(:group)
     end
 
-    after do
-        @class.clear
-    end
-
     it "should have a default provider" do
         @class.defaultprovider.should_not be_nil
     end
@@ -38,6 +34,6 @@ describe Puppet::Type.type(:group) do
 
     # #1407 - we need to declare the allowdupe param as boolean.
     it "should have a boolean method for determining if duplicates are allowed" do
-        @class.create(:name => "foo").methods.should be_include("allowdupe?")
+        @class.new(:name => "foo").methods.should be_include("allowdupe?")
     end
 end

data/spec/unit/type/macauthorization.rb

@@ -4,8 +4,8 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 macauth_type = Puppet::Type.type(:macauthorization)
 
-describe Puppet.type(:macauthorization), "when checking macauthorization objects" do
-    
+describe Puppet::Type.type(:macauthorization), "when checking macauthorization objects" do
+
     before do
         authplist = {}
         authplist["rules"] = { "foorule" => "foo" }
@@ -13,66 +13,99 @@ describe Puppet.type(:macauthorization), "when checking macauthorization objects
         provider_class = macauth_type.provider(macauth_type.providers[0])
         Plist.stubs(:parse_xml).with("/etc/authorization").returns(authplist)
         macauth_type.stubs(:defaultprovider).returns provider_class
+        @resource = macauth_type.new(:name => 'foo')
     end
-    
-    after do
-        macauth_type.clear
-    end
-        
-    
+
     describe "when validating attributes" do
-    
+
         parameters = [:name,]
-        properties = [:auth_type, :allow_root, :authenticate_user, :auth_class, 
-                      :comment, :group, :k_of_n, :mechanisms, :rule, 
+        properties = [:auth_type, :allow_root, :authenticate_user, :auth_class,
+                      :comment, :group, :k_of_n, :mechanisms, :rule,
                       :session_owner, :shared, :timeout, :tries]
-    
+
         parameters.each do |parameter|
             it "should have a %s parameter" % parameter do
                 macauth_type.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
             end
-    
+
             it "should have documentation for its %s parameter" % parameter do
                 macauth_type.attrclass(parameter).doc.should be_instance_of(String)
             end
         end
-    
+
         properties.each do |property|
             it "should have a %s property" % property do
                 macauth_type.attrclass(property).ancestors.should be_include(Puppet::Property)
             end
-    
+
             it "should have documentation for its %s property" % property do
                 macauth_type.attrclass(property).doc.should be_instance_of(String)
             end
         end
-    
+
     end
-    
+
     describe "when validating properties" do
-        
+
         it "should have a default provider inheriting from Puppet::Provider" do
             macauth_type.defaultprovider.ancestors.should be_include(Puppet::Provider)
         end
-    
+
         it "should be able to create an instance" do
             lambda {
-                macauth_type.create(:name => 'foo')
+                macauth_type.new(:name => 'foo')
             }.should_not raise_error
         end
-            
+
         it "should support :present as a value to :ensure" do
             lambda {
-                macauth_type.create(:name => "foo", :ensure => :present)
+                macauth_type.new(:name => "foo", :ensure => :present)
             }.should_not raise_error
         end
-            
+
         it "should support :absent as a value to :ensure" do
             lambda {
-                macauth_type.create(:name => "foo", :ensure => :absent)
+                macauth_type.new(:name => "foo", :ensure => :absent)
             }.should_not raise_error
         end
-    
+
     end
 
-end
+    [:k_of_n, :timeout, :tries].each do |property|
+        describe "when managing the #{property} property" do
+            it "should convert number-looking strings into actual numbers" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                prop.should = "300"
+                prop.should.must == 300
+            end
+            it "should support integers as a value" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                prop.should = 300
+                prop.should.must == 300
+            end
+            it "should raise an error for non-integer values" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                lambda { prop.should = "foo" }.should raise_error(Puppet::Error)
+            end
+        end
+    end
+
+    [:allow_root, :authenticate_user, :session_owner, :shared].each do |property|
+        describe "when managing the #{property} property" do
+            it "should convert boolean-looking false strings into actual booleans" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                prop.should = "false"
+                prop.should.must == :false
+            end
+            it "should convert boolean-looking true strings into actual booleans" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                prop.should = "true"
+                prop.should.must == :true
+            end
+            it "should raise an error for non-boolean values" do
+                prop = macauth_type.attrclass(property).new(:resource => @resource)
+                lambda { prop.should = "foo" }.should raise_error(Puppet::Error)
+            end
+        end
+    end
+end

data/spec/unit/type/mcx.rb

@@ -3,8 +3,8 @@
 # Copyright (C) 2008 Jeffrey J McCune.
 
 # This program and entire repository is free software; you can
-# redistribute it and/or modify it under the terms of the GNU 
-# General Public License as published by the Free Software 
+# redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software
 # Foundation; either version 2 of the License, or any later version.
 
 # This program is distributed in the hope that it will be useful,
@@ -58,20 +58,16 @@ describe mcx_type, "default values" do
         mcx_type.stubs(:defaultprovider).returns provider_class
     end
 
-    after :each do
-        mcx_type.clear
-    end
-
     it "should be nil for :ds_type" do
-        mcx_type.create(:name => '/Foo/bar')[:ds_type].should be_nil
+        mcx_type.new(:name => '/Foo/bar')[:ds_type].should be_nil
     end
 
     it "should be nil for :ds_name" do
-        mcx_type.create(:name => '/Foo/bar')[:ds_name].should be_nil
+        mcx_type.new(:name => '/Foo/bar')[:ds_name].should be_nil
     end
 
     it "should be nil for :content" do
-        mcx_type.create(:name => '/Foo/bar')[:content].should be_nil
+        mcx_type.new(:name => '/Foo/bar')[:content].should be_nil
     end
 
 end
@@ -83,25 +79,21 @@ describe mcx_type, "when validating properties" do
         mcx_type.stubs(:defaultprovider).returns provider_class
     end
 
-    after :each do
-        mcx_type.clear
-    end
-
     it "should be able to create an instance" do
         lambda {
-            mcx_type.create(:name => '/Foo/bar')
+            mcx_type.new(:name => '/Foo/bar')
         }.should_not raise_error
     end
 
     it "should support :present as a value to :ensure" do
         lambda {
-            mcx_type.create(:name => "/Foo/bar", :ensure => :present)
+            mcx_type.new(:name => "/Foo/bar", :ensure => :present)
         }.should_not raise_error
     end
 
     it "should support :absent as a value to :ensure" do
         lambda {
-            mcx_type.create(:name => "/Foo/bar", :ensure => :absent)
+            mcx_type.new(:name => "/Foo/bar", :ensure => :absent)
         }.should_not raise_error
     end
 

data/spec/unit/type/mount.rb

@@ -8,11 +8,9 @@ describe Puppet::Type.type(:mount) do
     end
 
     it "should have no default value for :ensure" do
-        mount = Puppet::Type.type(:mount).create(:name => "yay")
+        mount = Puppet::Type.type(:mount).new(:name => "yay")
         mount.should(:ensure).should be_nil
     end
-
-    after { Puppet::Type.type(:mount).clear }
 end
 
 describe Puppet::Type.type(:mount), "when validating attributes" do
@@ -36,38 +34,32 @@ describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
     end
 
     it "should support :present as a value to :ensure" do
-        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :present)
+        Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
     end
 
     it "should alias :unmounted to :present as a value to :ensure" do
-        mount = Puppet::Type.type(:mount).create(:name => "yay", :ensure => :unmounted)
+        mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
         mount.should(:ensure).should == :present
     end
 
     it "should support :absent as a value to :ensure" do
-        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :absent)
+        Puppet::Type.type(:mount).new(:name => "yay", :ensure => :absent)
     end
 
     it "should support :mounted as a value to :ensure" do
-        Puppet::Type.type(:mount).create(:name => "yay", :ensure => :mounted)
+        Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
     end
-
-    after { Puppet::Type.type(:mount).clear }
 end
 
 describe Puppet::Type.type(:mount)::Ensure do
     before :each do
         @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
         Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
-        @mount = Puppet::Type.type(:mount).create(:name => "yay", :check => :ensure)
+        @mount = Puppet::Type.type(:mount).new(:name => "yay", :check => :ensure)
 
         @ensure = @mount.property(:ensure)
     end
 
-    after :each do
-        Puppet::Type.type(:mount).clear
-    end
-    
     def mount_stub(params)
         Puppet::Type.type(:mount).validproperties.each do |prop|
             unless params[prop]
@@ -193,7 +185,7 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
     before do
         @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
         Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
-        @mount = Puppet::Type.type(:mount).create(:name => "yay", :ensure => :mounted)
+        @mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
 
         {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
             :ensure => :mounted}.each do
@@ -204,7 +196,7 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
 
         @mount.provider.stubs(:mounted?).returns true
 
-        @catalog = Puppet::Node::Catalog.new
+        @catalog = Puppet::Resource::Catalog.new
         @catalog.add_resource @mount
     end
 

data/spec/unit/type/noop_metaparam.rb

@@ -10,8 +10,6 @@ describe Puppet::Type.type(:file).attrclass(:noop) do
         @file = Puppet::Type.newfile :path => "/what/ever"
     end
 
-    after { Puppet::Type::File.clear }
-
     it "should accept true as a value" do
         lambda { @file[:noop] = true }.should_not raise_error
     end

data/spec/unit/type/package.rb

@@ -24,11 +24,9 @@ describe Puppet::Type.type(:package) do
     end
 
     it "should default to being installed" do
-        pkg = Puppet::Type.type(:package).create(:name => "yay")
+        pkg = Puppet::Type.type(:package).new(:name => "yay")
         pkg.should(:ensure).should == :present
     end
-
-    after { Puppet::Type.type(:package).clear }
 end
 
 describe Puppet::Type.type(:package), "when validating attributes" do
@@ -50,53 +48,51 @@ describe Puppet::Type.type(:package), "when validating attribute values" do
     end
 
     it "should support :present as a value to :ensure" do
-        Puppet::Type.type(:package).create(:name => "yay", :ensure => :present)
+        Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
     end
 
     it "should alias :installed to :present as a value to :ensure" do
-        pkg = Puppet::Type.type(:package).create(:name => "yay", :ensure => :installed)
+        pkg = Puppet::Type.type(:package).new(:name => "yay", :ensure => :installed)
         pkg.should(:ensure).should == :present
     end
 
     it "should support :absent as a value to :ensure" do
-        Puppet::Type.type(:package).create(:name => "yay", :ensure => :absent)
+        Puppet::Type.type(:package).new(:name => "yay", :ensure => :absent)
     end
 
     it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
         @provider.expects(:satisfies?).with(:purgeable).returns(true)
-        Puppet::Type.type(:package).create(:name => "yay", :ensure => :purged)
+        Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged)
     end
 
     it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
         @provider.expects(:satisfies?).with(:purgeable).returns(false)
-        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
+        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
     end
 
     it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
         @provider.expects(:satisfies?).with(:upgradeable).returns(true)
-        Puppet::Type.type(:package).create(:name => "yay", :ensure => :latest)
+        Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest)
     end
 
     it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
         @provider.expects(:satisfies?).with(:upgradeable).returns(false)
-        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
+        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
     end
 
     it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
         @provider.expects(:satisfies?).with(:versionable).returns(true)
-        Puppet::Type.type(:package).create(:name => "yay", :ensure => "1.0")
+        Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0")
     end
 
     it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
         @provider.expects(:satisfies?).with(:versionable).returns(false)
-        proc { Puppet::Type.type(:package).create(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
+        proc { Puppet::Type.type(:package).new(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
     end
 
     it "should accept any string as an argument to :source" do
-        proc { Puppet::Type.type(:package).create(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
+        proc { Puppet::Type.type(:package).new(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
     end
-
-    after { Puppet::Type.type(:package).clear }
 end
 
 module PackageEvaluationTesting
@@ -110,17 +106,11 @@ describe Puppet::Type.type(:package) do
         @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
         Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
         Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
-        @package = Puppet::Type.type(:package).create(:name => "yay")
+        @package = Puppet::Type.type(:package).new(:name => "yay")
 
-        @catalog = Puppet::Node::Catalog.new
+        @catalog = Puppet::Resource::Catalog.new
         @catalog.add_resource(@package)
     end
-    
-    after :each do
-        @catalog.clear(true)
-        Puppet::Type.type(:package).clear
-    end
-
 
     describe Puppet::Type.type(:package), "when it should be purged" do
         include PackageEvaluationTesting