puppet 2.7.6 → 2.7.8

data/spec/unit/resource/catalog_spec.rb

@@ -537,7 +537,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.resource(:file, @basepath+"/something").should equal(resource)
     end
 
-    it "should not create aliases for non-isomorphic resources whose names do not match their titles", :fails_on_windows => true  do
+    it "should not create aliases for non-isomorphic resources whose names do not match their titles" do
       resource = Puppet::Type.type(:exec).new(:title => "testing", :command => "echo", :path => %w{/bin /usr/bin /usr/local/bin})
 
       @catalog.add_resource(resource)

data/spec/unit/simple_graph_spec.rb

@@ -585,11 +585,11 @@ describe Puppet::SimpleGraph do
       x
     end
 
-    def admissible_sentinal_of(x)
+    def admissible_sentinel_of(x)
       @depgraph.vertex?(x) ? x : whit_called("admissible_#{x.ref}")
     end
 
-    def completed_sentinal_of(x)
+    def completed_sentinel_of(x)
       @depgraph.vertex?(x) ? x : whit_called("completed_#{x.ref}")
     end
 
@@ -617,28 +617,28 @@ describe Puppet::SimpleGraph do
 
     #    0) completed_X depends on admissible_X
     #
-    it "every container's completed sentinal should depend on its admissible sentinal" do
+    it "every container's completed sentinel should depend on its admissible sentinel" do
       containers.each { |container|
-        @depgraph.path_between(admissible_sentinal_of(container),completed_sentinal_of(container)).should be
+        @depgraph.path_between(admissible_sentinel_of(container),completed_sentinel_of(container)).should be
       }
     end
 
     #    1) contents of X each depend on admissible_X
     #
-    it "all contained objects should depend on their container's admissible sentinal" do
+    it "all contained objects should depend on their container's admissible sentinel" do
       containers.each { |container|
         contents_of(container).each { |leaf|
-          @depgraph.should be_edge(admissible_sentinal_of(container),admissible_sentinal_of(leaf))
+          @depgraph.should be_edge(admissible_sentinel_of(container),admissible_sentinel_of(leaf))
         }
       }
     end
 
     #    2) completed_X depends on each on the contents of X
     #
-    it "completed sentinals should depend on their container's contents" do
+    it "completed sentinels should depend on their container's contents" do
       containers.each { |container|
         contents_of(container).each { |leaf|
-          @depgraph.should be_edge(completed_sentinal_of(leaf),completed_sentinal_of(container))
+          @depgraph.should be_edge(completed_sentinel_of(leaf),completed_sentinel_of(container))
         }
       }
     end
@@ -665,7 +665,7 @@ describe Puppet::SimpleGraph do
 
     it "should retain labels on non-containment edges" do
       @explicit_dependencies.each { |f,t|
-        @depgraph.edges_between(completed_sentinal_of(f),admissible_sentinal_of(t))[0].label.should == {:callback => :refresh}
+        @depgraph.edges_between(completed_sentinel_of(f),admissible_sentinel_of(t))[0].label.should == {:callback => :refresh}
       }
     end
 

data/spec/unit/ssl/host_spec.rb

@@ -3,8 +3,7 @@ require 'spec_helper'
 
 require 'puppet/ssl/host'
 
-# REMIND: Fails on windows because there is no user provider yet
-describe Puppet::SSL::Host, :fails_on_windows => true do
+describe Puppet::SSL::Host do
   include PuppetSpec::Files
 
   before do
@@ -80,7 +79,7 @@ describe Puppet::SSL::Host, :fails_on_windows => true do
     Puppet::SSL::Host.localhost.should equal(host)
   end
 
-  it "should create a localhost cert if no cert is available and it is a CA with autosign and it is using DNS alt names" do
+  it "should create a localhost cert if no cert is available and it is a CA with autosign and it is using DNS alt names", :unless => Puppet.features.microsoft_windows? do
     Puppet[:autosign] = true
     Puppet[:confdir] = tmpdir('conf')
     Puppet[:dns_alt_names] = "foo,bar,baz"
@@ -96,8 +95,6 @@ describe Puppet::SSL::Host, :fails_on_windows => true do
 
   context "with dns_alt_names" do
     before :each do
-      Puppet[:dns_alt_names] = 'one, two'
-
       @key = stub('key content')
       key = stub('key', :generate => true, :content => @key)
       Puppet::SSL::Key.stubs(:new).returns key
@@ -108,17 +105,68 @@ describe Puppet::SSL::Host, :fails_on_windows => true do
       Puppet::SSL::CertificateRequest.indirection.stubs(:save).with(@cr)
     end
 
-    it "should not include subjectAltName if not the local node" do
-      @cr.expects(:generate).with(@key, {})
+    describe "explicitly specified" do
+      before :each do
+        Puppet[:dns_alt_names] = 'one, two'
+      end
+
+      it "should not include subjectAltName if not the local node" do
+        @cr.expects(:generate).with(@key, {})
 
-      Puppet::SSL::Host.new('not-the-' + Puppet[:certname]).generate
+        Puppet::SSL::Host.new('not-the-' + Puppet[:certname]).generate
+      end
+
+      it "should include subjectAltName if I am a CA" do
+        @cr.expects(:generate).
+          with(@key, { :dns_alt_names => Puppet[:dns_alt_names] })
+
+        Puppet::SSL::Host.localhost
+      end
     end
 
-    it "should include subjectAltName if I am a CA" do
-      @cr.expects(:generate).
-        with(@key, { :dns_alt_names => Puppet[:dns_alt_names] })
+    describe "implicitly defaulted" do
+      let(:ca) { stub('ca', :sign => nil) }
 
-      Puppet::SSL::Host.localhost
+      before :each do
+        Puppet[:dns_alt_names] = ''
+
+        Puppet::SSL::CertificateAuthority.stubs(:instance).returns ca
+      end
+
+      it "should not include defaults if we're not the CA" do
+        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns false
+
+        @cr.expects(:generate).with(@key, {})
+
+        Puppet::SSL::Host.localhost
+      end
+
+      it "should not include defaults if not the local node" do
+        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+
+        @cr.expects(:generate).with(@key, {})
+
+        Puppet::SSL::Host.new('not-the-' + Puppet[:certname]).generate
+      end
+
+      it "should not include defaults if we can't resolve our fqdn" do
+        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+        Facter.stubs(:value).with(:fqdn).returns nil
+
+        @cr.expects(:generate).with(@key, {})
+
+        Puppet::SSL::Host.localhost
+      end
+
+      it "should provide defaults if we're bootstrapping the local master" do
+        Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+        Facter.stubs(:value).with(:fqdn).returns 'web.foo.com'
+        Facter.stubs(:value).with(:domain).returns 'foo.com'
+
+        @cr.expects(:generate).with(@key, {:dns_alt_names => "puppet, web.foo.com, puppet.foo.com"})
+
+        Puppet::SSL::Host.localhost
+      end
     end
   end
 

data/spec/unit/transaction/report_spec.rb

@@ -204,14 +204,14 @@ describe Puppet::Transaction::Report do
     end
 
     describe "for times" do
-      it "should provide the total amount of time for each resource type", :fails_on_windows => true do
+      it "should provide the total amount of time for each resource type" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end
         add_statuses(3, :exec) do |status|
           status.evaluation_time = 2
         end
-        add_statuses(3, :mount) do |status|
+        add_statuses(3, :tidy) do |status|
           status.evaluation_time = 3
         end
 
@@ -219,7 +219,7 @@ describe Puppet::Transaction::Report do
 
         metric(:time, "file").should == 3
         metric(:time, "exec").should == 6
-        metric(:time, "mount").should == 9
+        metric(:time, "tidy").should == 9
       end
 
       it "should add any provided times from external sources" do

data/spec/unit/transaction_spec.rb

@@ -2,6 +2,7 @@
 require 'spec_helper'
 
 require 'puppet/transaction'
+require 'fileutils'
 
 def without_warnings
   flag = $VERBOSE
@@ -182,6 +183,333 @@ describe Puppet::Transaction do
     end
   end
 
+  describe "#eval_generate" do
+    let(:path) { tmpdir('eval_generate') }
+    let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
+    let(:graph) { @transaction.relationship_graph }
+
+    def find_vertex(type, title)
+      graph.vertices.find {|v| v.type == type and v.title == title}
+    end
+
+    before :each do
+      @filenames = []
+
+      'a'.upto('c') do |x|
+        @filenames << File.join(path,x)
+
+        'a'.upto('c') do |y|
+          @filenames << File.join(path,x,y)
+          FileUtils.mkdir_p(File.join(path,x,y))
+
+          'a'.upto('c') do |z|
+            @filenames << File.join(path,x,y,z)
+            FileUtils.touch(File.join(path,x,y,z))
+          end
+        end
+      end
+
+      @transaction.catalog.add_resource(resource)
+    end
+
+    it "should add the generated resources to the catalog" do
+      @transaction.eval_generate(resource)
+
+      @filenames.each do |file|
+        @transaction.catalog.resource(:file, file).should be_a(Puppet::Type.type(:file))
+      end
+    end
+
+    it "should add a sentinel whit for the resource" do
+      @transaction.eval_generate(resource)
+
+      find_vertex(:whit, "completed_#{path}").should be_a(Puppet::Type.type(:whit))
+    end
+
+    it "should replace dependencies on the resource with dependencies on the sentinel" do
+      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
+
+      @transaction.catalog.add_resource(dependent)
+
+      res = find_vertex(resource.type, resource.title)
+      generated = find_vertex(dependent.type, dependent.title)
+
+      graph.should be_edge(res, generated)
+
+      @transaction.eval_generate(resource)
+
+      sentinel = find_vertex(:whit, "completed_#{path}")
+
+      graph.should be_edge(sentinel, generated)
+      graph.should_not be_edge(res, generated)
+    end
+
+    it "should add an edge from the nearest ancestor to the generated resource" do
+      @transaction.eval_generate(resource)
+
+      @filenames.each do |file|
+        v = find_vertex(:file, file)
+        p = find_vertex(:file, File.dirname(file))
+
+        graph.should be_edge(p, v)
+      end
+    end
+
+    it "should add an edge from each generated resource to the sentinel" do
+      @transaction.eval_generate(resource)
+
+      sentinel = find_vertex(:whit, "completed_#{path}")
+      @filenames.each do |file|
+        v = find_vertex(:file, file)
+
+        graph.should be_edge(v, sentinel)
+      end
+    end
+
+    it "should add an edge from the resource to the sentinel" do
+      @transaction.eval_generate(resource)
+
+      res = find_vertex(:file, path)
+      sentinel = find_vertex(:whit, "completed_#{path}")
+
+      graph.should be_edge(res, sentinel)
+    end
+
+    it "should return false if an error occured when generating resources" do
+      resource.stubs(:eval_generate).raises(Puppet::Error)
+
+      @transaction.eval_generate(resource).should == false
+    end
+
+    it "should return true if resources were generated" do
+      @transaction.eval_generate(resource).should == true
+    end
+
+    it "should not add a sentinel if no resources are generated" do
+      path2 = tmpfile('empty')
+      other_file = Puppet::Type.type(:file).new(:path => path2)
+
+      @transaction.catalog.add_resource(other_file)
+
+      @transaction.eval_generate(other_file).should == false
+
+      find_vertex(:whit, "completed_#{path2}").should be_nil
+    end
+  end
+
+  describe "#unblock" do
+    let(:graph) { @transaction.relationship_graph }
+    let(:resource) { Puppet::Type.type(:notify).new(:name => 'foo') }
+
+    it "should calculate the number of blockers if it's not known" do
+      graph.add_vertex(resource)
+      3.times do |i|
+        other = Puppet::Type.type(:notify).new(:name => i.to_s)
+        graph.add_vertex(other)
+        graph.add_edge(other, resource)
+      end
+
+      graph.unblock(resource)
+
+      graph.blockers[resource].should == 2
+    end
+
+    it "should decrement the number of blockers if there are any" do
+      graph.blockers[resource] = 40
+
+      graph.unblock(resource)
+
+      graph.blockers[resource].should == 39
+    end
+
+    it "should warn if there are no blockers" do
+      vertex = stub('vertex')
+      vertex.expects(:warning).with "appears to have a negative number of dependencies"
+      graph.blockers[vertex] = 0
+
+      graph.unblock(vertex)
+    end
+
+    it "should return true if the resource is now unblocked" do
+      graph.blockers[resource] = 1
+
+      graph.unblock(resource).should == true
+    end
+
+    it "should return false if the resource is still blocked" do
+      graph.blockers[resource] = 2
+
+      graph.unblock(resource).should == false
+    end
+  end
+
+  describe "#finish" do
+    let(:graph) { @transaction.relationship_graph }
+    let(:path) { tmpdir('eval_generate') }
+    let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
+
+    before :each do
+      @transaction.catalog.add_resource(resource)
+    end
+
+    it "should unblock the resource's dependents and queue them if ready" do
+      dependent = Puppet::Type.type(:file).new(:path => tmpfile('dependent'), :require => resource)
+      more_dependent = Puppet::Type.type(:file).new(:path => tmpfile('more_dependent'), :require => [resource, dependent])
+      @transaction.catalog.add_resource(dependent, more_dependent)
+
+      graph.finish(resource)
+
+      graph.blockers[dependent].should == 0
+      graph.blockers[more_dependent].should == 1
+
+      key = graph.unguessable_deterministic_key[dependent]
+
+      graph.ready[key].must == dependent
+
+      graph.ready.should_not be_has_key(graph.unguessable_deterministic_key[more_dependent])
+    end
+
+    it "should mark the resource as done" do
+      graph.finish(resource)
+
+      graph.done[resource].should == true
+    end
+  end
+
+  describe "when traversing" do
+    let(:graph) { @transaction.relationship_graph }
+    let(:path) { tmpdir('eval_generate') }
+    let(:resource) { Puppet::Type.type(:file).new(:path => path, :recurse => true) }
+
+    before :each do
+      @transaction.catalog.add_resource(resource)
+    end
+
+    it "should clear blockers if resources are added" do
+      graph.blockers['foo'] = 3
+      graph.blockers['bar'] = 4
+
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      @transaction.expects(:eval_generate).with(resource).returns true
+
+      graph.traverse {}
+
+      graph.blockers.should be_empty
+    end
+
+    it "should yield the resource even if eval_generate is called" do
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      @transaction.expects(:eval_generate).with(resource).returns true
+
+      yielded = false
+      graph.traverse do |res|
+        yielded = true if res == resource
+      end
+
+      yielded.should == true
+    end
+
+    it "should prefetch the provider if necessary" do
+      @transaction.expects(:prefetch_if_necessary).with(resource)
+
+      graph.traverse {}
+    end
+
+    it "should not clear blockers if resources aren't added" do
+      graph.blockers['foo'] = 3
+      graph.blockers['bar'] = 4
+
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      @transaction.expects(:eval_generate).with(resource).returns false
+
+      graph.traverse {}
+
+      graph.blockers.should == {'foo' => 3, 'bar' => 4, resource => 0}
+    end
+
+    it "should unblock all dependents of the resource" do
+      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
+      dependent2 = Puppet::Type.type(:notify).new(:name => "goodbye", :require => resource)
+
+      @transaction.catalog.add_resource(dependent, dependent2)
+
+      graph.blockers[dependent].should == 1
+      graph.blockers[dependent2].should == 1
+
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      graph.traverse {}
+
+      graph.blockers[dependent].should == 0
+      graph.blockers[dependent2].should == 0
+    end
+
+    it "should enqueue any unblocked dependents" do
+      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
+      dependent2 = Puppet::Type.type(:notify).new(:name => "goodbye", :require => resource)
+
+      @transaction.catalog.add_resource(dependent, dependent2)
+
+      graph.blockers[dependent].should == 1
+      graph.blockers[dependent2].should == 1
+
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      seen = []
+
+      graph.traverse do |res|
+        seen << res
+      end
+
+      seen.should =~ [resource, dependent, dependent2]
+    end
+
+    it "should mark the resource done" do
+      graph.ready[graph.unguessable_deterministic_key[resource]] = resource
+
+      graph.traverse {}
+
+      graph.done[resource].should == true
+    end
+
+    it "should not evaluate the resource if it's not suitable" do
+      resource.stubs(:suitable?).returns false
+
+      graph.traverse do |resource|
+        raise "evaluated a resource"
+      end
+    end
+
+    it "should defer an unsuitable resource unless it can't go on" do
+      other = Puppet::Type.type(:notify).new(:name => "hello")
+      @transaction.catalog.add_resource(other)
+
+      # Show that we check once, then get the resource back and check again
+      resource.expects(:suitable?).twice.returns(false).then.returns(true)
+
+      graph.traverse {}
+    end
+
+    it "should fail unsuitable resources and go on if it gets blocked" do
+      dependent = Puppet::Type.type(:notify).new(:name => "hello", :require => resource)
+      @transaction.catalog.add_resource(dependent)
+
+      resource.stubs(:suitable?).returns false
+
+      evaluated = []
+      graph.traverse do |res|
+        evaluated << res
+      end
+
+      # We should have gone on to evaluate the children
+      evaluated.should == [dependent]
+      @transaction.resource_status(resource).should be_failed
+    end
+  end
+
   describe "when generating resources" do
     it "should call 'generate' on all created resources" do
       first = Puppet::Type.type(:notify).new(:name => "first")
@@ -199,7 +527,7 @@ describe Puppet::Transaction do
     end
 
     it "should finish all resources" do
-      generator = stub 'generator', :depthfirst? => true, :tags => []
+      generator = stub 'generator', :depthfirst? => true, :tags => [], :ref => "Some[resource]"
       resource = stub 'resource', :tag => nil
 
       @catalog = Puppet::Resource::Catalog.new
@@ -232,8 +560,8 @@ describe Puppet::Transaction do
     end
 
     it "should copy all tags to the newly generated resources" do
-      child = stub 'child'
-      generator = stub 'resource', :tags => ["one", "two"]
+      child = stub 'child', :ref => "Some[child_resource]"
+      generator = stub 'resource', :tags => ["one", "two"], :ref => "Some[resource]"
 
       @catalog = Puppet::Resource::Catalog.new
       @transaction = Puppet::Transaction.new(@catalog)
@@ -351,17 +679,72 @@ describe Puppet::Transaction do
   end
 
   describe "when prefetching" do
-    it "should match resources by name, not title" do
-      @catalog = Puppet::Resource::Catalog.new
-      @transaction = Puppet::Transaction.new(@catalog)
+    let(:catalog) { Puppet::Resource::Catalog.new }
+    let(:transaction) { Puppet::Transaction.new(catalog) }
+    let(:resource) { Puppet::Type.type(:sshkey).create :title => "foo", :name => "bar", :type => :dsa, :key => "eh", :provider => :parsed }
+    let(:resource2) { Puppet::Type.type(:package).create :title => "blah", :provider => "apt" }
 
-      # Have both a title and name
-      resource = Puppet::Type.type(:sshkey).create :title => "foo", :name => "bar", :type => :dsa, :key => "eh"
-      @catalog.add_resource resource
+    before :each do
+      catalog.add_resource resource
+      catalog.add_resource resource2
+    end
+
+
+    describe "#resources_by_provider" do
+      it "should fetch resources by their type and provider" do
+        transaction.resources_by_provider(:sshkey, :parsed).should == {
+          resource.name => resource,
+        }
+
+        transaction.resources_by_provider(:package, :apt).should == {
+          resource2.name => resource2,
+        }
+      end
+
+      it "should omit resources whose types don't use providers" do
+        # faking the sshkey type not to have a provider
+        resource.class.stubs(:attrclass).returns nil
+
+        transaction.resources_by_provider(:sshkey, :parsed).should == {}
+      end
 
+      it "should return empty hash for providers with no resources" do
+        transaction.resources_by_provider(:package, :yum).should == {}
+      end
+    end
+
+    it "should match resources by name, not title" do
       resource.provider.class.expects(:prefetch).with("bar" => resource)
 
-      @transaction.prefetch
+      transaction.prefetch_if_necessary(resource)
+    end
+
+    it "should not prefetch a provider which has already been prefetched" do
+      transaction.prefetched_providers[:sshkey][:parsed] = true
+
+      resource.provider.class.expects(:prefetch).never
+
+      transaction.prefetch_if_necessary(resource)
+    end
+
+    it "should mark the provider prefetched" do
+      resource.provider.class.stubs(:prefetch)
+
+      transaction.prefetch_if_necessary(resource)
+
+      transaction.prefetched_providers[:sshkey][:parsed].should be_true
+    end
+
+    it "should prefetch resources without a provider if prefetching the default provider" do
+      other = Puppet::Type.type(:sshkey).create :name => "other"
+
+      other.instance_variable_set(:@provider, nil)
+
+      catalog.add_resource other
+
+      resource.provider.class.expects(:prefetch).with('bar' => resource, 'other' => other)
+
+      transaction.prefetch_if_necessary(resource)
     end
   end
 
@@ -407,7 +790,7 @@ describe Puppet::Transaction do
       before do
         @resource = Puppet::Type.type(:notify).new :title => "foobar"
         @catalog.add_resource @resource
-        @transaction.stubs(:prepare)
+        @transaction.stubs(:add_dynamically_generated_resources)
       end
 
       it 'should stop processing if :stop_processing? is true' do