puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/graph/title_hash_prioritizer_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'puppet/graph'
+
+describe Puppet::Graph::TitleHashPrioritizer do
+  it "produces different priorities for different resource references" do
+    prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+
+    expect(prioritizer.generate_priority_for(resource(:notify, "one"))).to_not(
+      eq(prioritizer.generate_priority_for(resource(:notify, "two"))))
+  end
+
+  it "always produces the same priority for the same resource ref" do
+    a_prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+    another_prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+
+    expect(a_prioritizer.generate_priority_for(resource(:notify, "one"))).to(
+      eq(another_prioritizer.generate_priority_for(resource(:notify, "one"))))
+  end
+
+  it "does not use the container when generating priorities" do
+    prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+
+    expect(prioritizer.generate_priority_contained_in(nil, resource(:notify, "one"))).to(
+      eq(prioritizer.generate_priority_for(resource(:notify, "one"))))
+  end
+
+  it "can retrieve a previously provided priority with the same resource" do
+    prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+    resource = resource(:notify, "title")
+
+    generated = prioritizer.generate_priority_for(resource)
+
+    expect(prioritizer.priority_of(resource)).to eq(generated)
+  end
+
+  it "can not retrieve the priority of a resource with a different resource with the same title" do
+    prioritizer = Puppet::Graph::TitleHashPrioritizer.new
+    resource = resource(:notify, "title")
+    different_resource = resource(:notify, "title")
+
+    generated = prioritizer.generate_priority_for(resource)
+
+    expect(prioritizer.priority_of(different_resource)).to be_nil
+  end
+
+  def resource(type, title)
+    Puppet::Resource.new(type, title)
+  end
+end

data/spec/unit/hiera_puppet_spec.rb

@@ -35,7 +35,7 @@ describe 'HieraPuppet' do
   end
 
   describe 'HieraPuppet#hiera_config_file' do
-    it "should return nil when we cannot derive the hiera config file form Puppet.settings" do
+    it "should return nil when we cannot derive the hiera config file from Puppet.settings" do
       begin
         Puppet.settings[:hiera_config] = nil
       rescue ArgumentError => detail

data/spec/unit/indirector/catalog/active_record_spec.rb

@@ -89,9 +89,11 @@ describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_datab
     end
 
     it "should set the last compile time on the host" do
-      now = Time.now
+      before = Time.now
       terminus.save(request)
-      Puppet::Rails::Host.find_by_name("foo").last_compile.should be_within(1).of(now)
+      after = Time.now
+
+      Puppet::Rails::Host.find_by_name("foo").last_compile.should be_between(before, after)
     end
 
     it "should save the Rails host instance" do

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -133,50 +133,44 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when extracting facts from the request" do
     before do
+      Puppet::Node::Facts.indirection.terminus_class = :memory
       Facter.stubs(:value).returns "something"
       @compiler = Puppet::Resource::Catalog::Compiler.new
-      @request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
 
       @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
-      Puppet::Node::Facts.indirection.stubs(:save).returns(nil)
+    end
+
+    def a_request_that_contains(facts)
+      request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+      request.options[:facts_format] = "pson"
+      request.options[:facts] = CGI.escape(facts.render(:pson))
+      request
     end
 
     it "should do nothing if no facts are provided" do
-      Puppet::Node::Facts.indirection.expects(:convert_from).never
-      @request.options[:facts] = nil
+      request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+      request.options[:facts] = nil
 
-      @compiler.extract_facts_from_request(@request)
+      @compiler.extract_facts_from_request(request).should be_nil
     end
 
-    it "should use the Facts class to deserialize the provided facts and update the timestamp" do
-      @request.options[:facts_format] = "foo"
-      @request.options[:facts] = "bar"
-      Puppet::Node::Facts.expects(:convert_from).returns @facts
-
+    it "deserializes the facts and timestamps them" do
       @facts.timestamp = Time.parse('2010-11-01')
-      @now = Time.parse('2010-11-02')
-      Time.stubs(:now).returns(@now)
-
-      @compiler.extract_facts_from_request(@request)
-      @facts.timestamp.should == @now
-    end
+      request = a_request_that_contains(@facts)
+      now = Time.parse('2010-11-02')
+      Time.stubs(:now).returns(now)
 
-    it "should use the provided fact format" do
-      @request.options[:facts_format] = "foo"
-      @request.options[:facts] = "bar"
-      Puppet::Node::Facts.expects(:convert_from).with { |format, text| format == "foo" }.returns @facts
+      facts = @compiler.extract_facts_from_request(request)
 
-      @compiler.extract_facts_from_request(@request)
+      facts.timestamp.should == now
     end
 
     it "should convert the facts into a fact instance and save it" do
-      @request.options[:facts_format] = "foo"
-      @request.options[:facts] = "bar"
-      Puppet::Node::Facts.expects(:convert_from).returns @facts
+      request = a_request_that_contains(@facts)
 
-      Puppet::Node::Facts.indirection.expects(:save).with(@facts)
+      Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts))
 
-      @compiler.extract_facts_from_request(@request)
+      @compiler.extract_facts_from_request(request)
     end
   end
 

data/spec/unit/indirector/face_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Indirector::Face do
 
   describe "as an instance" do
     it "should be able to determine its indirection" do
-      # Loading actions here an get, um, complicated
+      # Loading actions here can get, um, complicated
       Puppet::Face.stubs(:load_actions)
       Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection.should equal(Puppet::Resource::Catalog.indirection)
     end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -80,13 +80,23 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it "should convert all facts into strings" do
+    it "should convert facts into strings when stringify_facts is true" do
+      Puppet[:stringify_facts] = true
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:stringify)
 
       @facter.find(@request)
     end
+
+    it "should sanitize facts when stringify_facts is false" do
+      Puppet[:stringify_facts] = false
+      facts = Puppet::Node::Facts.new("foo")
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:sanitize)
+
+      @facter.find(@request)
+    end
   end
 
   describe Puppet::Node::Facts::Facter, " when saving facts" do

data/spec/unit/indirector/facts/network_device_spec.rb

@@ -55,13 +55,23 @@ describe Puppet::Node::Facts::NetworkDevice do
       @device.find(@request)
     end
 
-    it "should convert all facts into strings" do
+    it "should convert facts into strings when stringify_facts is true" do
+      Puppet[:stringify_facts] = true
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:stringify)
 
       @device.find(@request)
     end
+
+    it "should sanitizer facts when stringify_facts is false" do
+      Puppet[:stringify_facts] = false
+      facts = Puppet::Node::Facts.new("foo")
+      Puppet::Node::Facts.expects(:new).returns facts
+      facts.expects(:sanitize)
+
+      @device.find(@request)
+    end
   end
 
   describe Puppet::Node::Facts::NetworkDevice, " when saving facts" do

data/spec/unit/indirector/hiera_spec.rb

@@ -127,7 +127,7 @@ describe Puppet::Indirector::Hiera do
 
     let(:data_binder) { @hiera_class.new }
 
-    it "support looking up an integer" do
+    it "should support looking up an integer" do
       data_binder.find(request_integer).should == 3000
     end
 

data/spec/unit/indirector/instrumentation_data/local_spec.rb

@@ -28,7 +28,7 @@ describe Puppet::Indirector::InstrumentationData::Local do
   end
 
   describe "when finding instrumentation data" do
-    it "should return a Instrumentation Data instance matching the key" do
+    it "should return an Instrumentation Data instance matching the key" do
     end
   end
 

data/spec/unit/indirector/instrumentation_listener/local_spec.rb

@@ -28,7 +28,7 @@ describe Puppet::Indirector::InstrumentationListener::Local do
   end
 
   describe "when finding listeners" do
-    it "should return a Instrumentation Listener instance matching the key" do
+    it "should return an Instrumentation Listener instance matching the key" do
       Puppet::Util::Instrumentation.expects(:[]).with("me").returns(:instance)
       @listener.find(@request).should == :instance
     end

data/spec/unit/indirector/request_spec.rb

@@ -33,15 +33,15 @@ describe Puppet::Indirector::Request do
     end
 
     it "should support options specified as a hash" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.should_not raise_error(ArgumentError)
+      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.to_not raise_error
     end
 
     it "should support nil options" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.should_not raise_error(ArgumentError)
+      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.to_not raise_error
     end
 
     it "should support unspecified options" do
-      lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
+      expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.to_not raise_error
     end
 
     it "should use an empty options hash if nil was provided" do
@@ -190,7 +190,7 @@ describe Puppet::Indirector::Request do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
-    lambda { request.model }.should raise_error(ArgumentError)
+    expect { request.model }.to raise_error(ArgumentError)
   end
 
   it "should have a method for determining if the request is plural or singular" do
@@ -243,76 +243,129 @@ describe Puppet::Indirector::Request do
   end
 
   describe "when building a query string from its options" do
-    before do
-      @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
+    def a_request_with_options(options)
+      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
+    end
+
+    def the_parsed_query_string_from(request)
+      CGI.parse(request.query_string.sub(/^\?/, ''))
     end
 
     it "should return an empty query string if there are no options" do
-      @request.stubs(:options).returns nil
-      @request.query_string.should == ""
+      request = a_request_with_options(nil)
+
+      request.query_string.should == ""
     end
 
     it "should return an empty query string if the options are empty" do
-      @request.stubs(:options).returns({})
-      @request.query_string.should == ""
+      request = a_request_with_options({})
+
+      request.query_string.should == ""
     end
 
     it "should prefix the query string with '?'" do
-      @request.stubs(:options).returns(:one => "two")
-      @request.query_string.should =~ /^\?/
+      request = a_request_with_options(:one => "two")
+
+      request.query_string.should =~ /^\?/
     end
 
     it "should include all options in the query string, separated by '&'" do
-      @request.stubs(:options).returns(:one => "two", :three => "four")
-      @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
+      request = a_request_with_options(:one => "two", :three => "four")
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["two"],
+        "three" => ["four"]
+      }
     end
 
     it "should ignore nil options" do
-      @request.stubs(:options).returns(:one => "two", :three => nil)
-      @request.query_string.should_not be_include("three")
+      request = a_request_with_options(:one => "two", :three => nil)
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["two"]
+      }
     end
 
     it "should convert 'true' option values into strings" do
-      @request.stubs(:options).returns(:one => true)
-      @request.query_string.should == "?one=true"
+      request = a_request_with_options(:one => true)
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["true"]
+      }
     end
 
     it "should convert 'false' option values into strings" do
-      @request.stubs(:options).returns(:one => false)
-      @request.query_string.should == "?one=false"
+      request = a_request_with_options(:one => false)
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["false"]
+      }
     end
 
     it "should convert to a string all option values that are integers" do
-      @request.stubs(:options).returns(:one => 50)
-      @request.query_string.should == "?one=50"
+      request = a_request_with_options(:one => 50)
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["50"]
+      }
     end
 
     it "should convert to a string all option values that are floating point numbers" do
-      @request.stubs(:options).returns(:one => 1.2)
-      @request.query_string.should == "?one=1.2"
+      request = a_request_with_options(:one => 1.2)
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["1.2"]
+      }
     end
 
     it "should CGI-escape all option values that are strings" do
-      escaping = CGI.escape("one two")
-      @request.stubs(:options).returns(:one => "one two")
-      @request.query_string.should == "?one=#{escaping}"
+      request = a_request_with_options(:one => "one two")
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["one two"]
+      }
     end
 
-    it "should YAML-dump and CGI-escape arrays" do
-      escaping = CGI.escape(YAML.dump(%w{one two}))
-      @request.stubs(:options).returns(:one => %w{one two})
-      @request.query_string.should == "?one=#{escaping}"
+    it "should convert an array of values into multiple entries for the same key" do
+      request = a_request_with_options(:one => %w{one two})
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["one", "two"]
+      }
+    end
+
+    it "should stringify simple data types inside an array" do
+      request = a_request_with_options(:one => ['one', nil])
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["one"]
+      }
+    end
+
+    it "should error if an array contains another array" do
+      request = a_request_with_options(:one => ['one', ["not allowed"]])
+
+      expect { request.query_string }.to raise_error(ArgumentError)
+    end
+
+    it "should error if an array contains illegal data" do
+      request = a_request_with_options(:one => ['one', { :not => "allowed" }])
+
+      expect { request.query_string }.to raise_error(ArgumentError)
     end
 
     it "should convert to a string and CGI-escape all option values that are symbols" do
-      escaping = CGI.escape("sym bol")
-      @request.stubs(:options).returns(:one => :"sym bol")
-      @request.query_string.should == "?one=#{escaping}"
+      request = a_request_with_options(:one => :"sym bol")
+
+      the_parsed_query_string_from(request).should == {
+        "one" => ["sym bol"]
+      }
     end
 
     it "should fail if options other than booleans or strings are provided" do
-      @request.stubs(:options).returns(:one => {:one => :two})
-      lambda { @request.query_string }.should raise_error(ArgumentError)
+      request = a_request_with_options(:one => { :one => :two })
+
+      expect { request.query_string }.to raise_error(ArgumentError)
     end
   end
 
@@ -372,7 +425,7 @@ describe Puppet::Indirector::Request do
     it "should fail if no key is provided" do
       json = PSON.parse(@request.to_pson)
       json['data'].delete("key")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
+      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should set its indirector name" do
@@ -382,7 +435,7 @@ describe Puppet::Indirector::Request do
     it "should fail if no type is provided" do
       json = PSON.parse(@request.to_pson)
       json['data'].delete("type")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
+      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should set its method" do
@@ -392,7 +445,7 @@ describe Puppet::Indirector::Request do
     it "should fail if no method is provided" do
       json = PSON.parse(@request.to_pson)
       json['data'].delete("method")
-      lambda { from_json(json.to_pson) }.should raise_error(ArgumentError)
+      expect { from_json(json.to_pson) }.to raise_error(ArgumentError)
     end
 
     it "should initialize with all attributes and options" do