Merge branch 'ticket/2.6.x/4416' into 2.6.x

4 files changed, 97 insertions, 44 deletions

diff --git a/lib/puppet/metatype/manager.rb b/lib/puppet/metatype/manager.rb
index 12cbf645c..597a89f31 100644
--- a/lib/puppet/metatype/manager.rb
+++ b/lib/puppet/metatype/manager.rb
@@ -61,10 +61,9 @@ module Manager
 
     # Then create the class.
 
-          klass = genclass(
-        name,
+    klass = genclass(
+      name,
       :parent => (parent || Puppet::Type),
-        
       :overwrite => true,
       :hash => @types,
       :attributes => options,
@@ -87,14 +86,11 @@ module Manager
 
     # Now set up autoload any providers that might exist for this type.
 
-          klass.providerloader = Puppet::Util::Autoload.new(
-        klass,
-        
-      "puppet/provider/#{klass.name.to_s}"
-    )
+    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
 
-    # We have to load everything so that we can figure out the default type.
+    # We have to load everything so that we can figure out the default provider.
     klass.providerloader.loadall
+    klass.providify unless klass.providers.empty?
 
     klass
   end
@@ -103,11 +99,7 @@ module Manager
   def rmtype(name)
     # Then create the class.
 
-          klass = rmclass(
-        name,
-        
-      :hash => @types
-    )
+    klass = rmclass(name, :hash => @types)
 
     singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
   end
@@ -132,12 +124,7 @@ module Manager
   # Create a loader for Puppet types.
   def typeloader
     unless defined?(@typeloader)
-
-            @typeloader = Puppet::Util::Autoload.new(
-        self,
-        
-        "puppet/type", :wrap => false
-      )
+      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
     end
 
     @typeloader
diff --git a/lib/puppet/type.rb b/lib/puppet/type.rb
index d24cc8554..1933097da 100644
--- a/lib/puppet/type.rb
+++ b/lib/puppet/type.rb
@@ -1416,9 +1416,8 @@ class Type
   def self.provide(name, options = {}, &block)
     name = Puppet::Util.symbolize(name)
 
-    if obj = provider_hash[name]
+    if unprovide(name)
       Puppet.debug "Reloading #{name} #{self.name} provider"
-      unprovide(name)
     end
 
     parent = if pname = options[:parent]
@@ -1441,16 +1440,14 @@ class Type
 
     self.providify
 
-
-      provider = genclass(
-        name,
-      :parent => parent,
-      :hash => provider_hash,
-      :prefix => "Provider",
-      :block => block,
-      :include => feature_module,
-      :extend => feature_module,
-
+    provider = genclass(
+      name,
+      :parent     => parent,
+      :hash       => provider_hash,
+      :prefix     => "Provider",
+      :block      => block,
+      :include    => feature_module,
+      :extend     => feature_module,
       :attributes => options
     )
 
@@ -1510,18 +1507,11 @@ class Type
   end
 
   def self.unprovide(name)
-    if provider_hash.has_key? name
-
-      rmclass(
-        name,
-        :hash => provider_hash,
-
-        :prefix => "Provider"
-      )
-      if @defaultprovider and @defaultprovider.name == name
-        @defaultprovider = nil
-      end
+    if @defaultprovider and @defaultprovider.name == name
+      @defaultprovider = nil
     end
+
+    rmclass(name, :hash => provider_hash, :prefix => "Provider")
   end
 
   # Return an array of all of the suitable providers.
@@ -1581,7 +1571,6 @@ class Type
 
       # Collect the current prereqs
       list.each { |dep|
-        obj = nil
         # Support them passing objects directly, to save some effort.
         unless dep.is_a? Puppet::Type
           # Skip autorequires that we aren't managing
diff --git a/spec/integration/type_spec.rb b/spec/integration/type_spec.rb
index 957dfe344..74e268a3c 100755
--- a/spec/integration/type_spec.rb
+++ b/spec/integration/type_spec.rb
@@ -19,4 +19,15 @@ describe Puppet::Type do
 
     type.provider(:myprovider).should equal(provider)
   end
+
+  it "should not lose its provider parameter when it is reloaded" do
+    type = Puppet::Type.newtype(:reload_test_type)
+
+    provider = type.provide(:test_provider)
+
+    # reload it
+    type = Puppet::Type.newtype(:reload_test_type)
+
+    type.parameters.should include(:provider)
+  end
 end
diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index 9b1f20500..442c759e7 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -165,6 +165,72 @@ describe Puppet::Type do
     end
   end
 
+  describe "when creating a provider" do
+    before :each do
+      @type = Puppet::Type.newtype(:provider_test_type)
+    end
+
+    after :each do
+      @type.provider_hash.clear
+    end
+
+    it "should create a subclass of Puppet::Provider for the provider" do
+      provider = @type.provide(:test_provider)
+
+      provider.ancestors.should include(Puppet::Provider)
+    end
+
+    it "should use a parent class if specified" do
+      parent_provider = @type.provide(:parent_provider)
+      child_provider  = @type.provide(:child_provider, :parent => parent_provider)
+
+      child_provider.ancestors.should include(parent_provider)
+    end
+
+    it "should use a parent class if specified by name" do
+      parent_provider = @type.provide(:parent_provider)
+      child_provider  = @type.provide(:child_provider, :parent => :parent_provider)
+
+      child_provider.ancestors.should include(parent_provider)
+    end
+
+    it "should raise an error when the parent class can't be found" do
+      expect {
+        @type.provide(:child_provider, :parent => :parent_provider)
+      }.to raise_error(Puppet::DevError, /Could not find parent provider.+parent_provider/)
+    end
+
+    it "should ensure its type has a 'provider' parameter" do
+      @type.provide(:test_provider)
+
+      @type.parameters.should include(:provider)
+    end
+
+    it "should remove a previously registered provider with the same name" do
+      old_provider = @type.provide(:test_provider)
+      new_provider = @type.provide(:test_provider)
+
+      old_provider.should_not equal(new_provider)
+    end
+
+    it "should register itself as a provider for the type" do
+      provider = @type.provide(:test_provider)
+
+      provider.should == @type.provider(:test_provider)
+    end
+
+    it "should create a provider when a provider with the same name previously failed" do
+      @type.provide(:test_provider) do
+        raise "failed to create this provider"
+      end rescue nil
+
+      provider = @type.provide(:test_provider)
+
+      provider.ancestors.should include(Puppet::Provider)
+      provider.should == @type.provider(:test_provider)
+    end
+  end
+
   describe "when choosing a default provider" do
     it "should choose the provider with the highest specificity" do
       # Make a fake type