puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/forge/repository_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 require 'net/http'
 require 'puppet/forge/repository'
@@ -91,7 +92,7 @@ describe Puppet::Forge::Repository do
         http.expects(:request).with() do |request|
           puppet_version = /Puppet\/\d+\..*/
           os_info = /\(.*\)/
-          ruby_version = /Ruby\/\d+\.\d+\.\d+(-p\d+)? \(\d{4}-\d{2}-\d{2}; .*\)/
+          ruby_version = /Ruby\/\d+\.\d+\.\d+(-p-?\d+)? \(\d{4}-\d{2}-\d{2}; .*\)/
 
           request["User-Agent"] =~ /^#{consumer_version} #{puppet_version} #{os_info} #{ruby_version}/
         end
@@ -100,6 +101,15 @@ describe Puppet::Forge::Repository do
       repository.make_http_request("the_path")
     end
 
+    it "escapes the received URI" do
+      unescaped_uri = "héllo world !! ç à"
+      performs_an_http_request do |http|
+        http.expects(:request).with(responds_with(:path, URI.escape(unescaped_uri)))
+      end
+
+      repository.make_http_request(unescaped_uri)
+    end
+
     def performs_an_http_request(result = nil, &block)
       http = mock("http client")
       yield http

data/spec/unit/forge_spec.rb

@@ -36,15 +36,25 @@ describe Puppet::Forge do
 
   context "when the connection to the forge fails" do
     before :each do
-      repository_responds_with(stub(:body => '{}', :code => '404'))
+      repository_responds_with(stub(:body => '{}', :code => '404', :message => "not found"))
     end
 
     it "raises an error for search" do
-      expect { forge.search('bacula') }.to raise_error RuntimeError
+      expect { forge.search('bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'bacula'. Detail: 404 not found."
     end
 
     it "raises an error for remote_dependency_info" do
-      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error RuntimeError
+      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: 404 not found."
+    end
+  end
+
+  context "when the API responses with an error" do
+    before :each do
+      repository_responds_with(stub(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
+    end
+
+    it "raises an error for remote_dependency_info" do
+      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: invalid module / 410 Gone."
     end
   end
 end

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'hiera/backend/puppet_backend'
 require 'hiera/scope'
+require 'hiera/config'
 
 describe Hiera::Backend::Puppet_backend do
 

data/spec/unit/hiera/scope_spec.rb

@@ -2,59 +2,82 @@ require 'spec_helper'
 require 'hiera/scope'
 
 describe Hiera::Scope do
+  let(:real) { Puppet::Parser::Scope.new_for_test_harness("test_node") }
+  let(:scope) { Hiera::Scope.new(real) }
+
   describe "#initialize" do
     it "should store the supplied puppet scope" do
-      real = {}
-      scope = Hiera::Scope.new(real)
       scope.real.should == real
     end
   end
 
   describe "#[]" do
+    it "should return nil when no value is found" do
+      scope["foo"].should == nil
+    end
+
     it "should treat '' as nil" do
-      real = mock
-      real.expects(:lookupvar).with("foo").returns("")
+      real["foo"] = ""
 
-      scope = Hiera::Scope.new(real)
       scope["foo"].should == nil
     end
 
-    it "sould return found data" do
-      real = mock
-      real.expects(:lookupvar).with("foo").returns("bar")
+    it "should return found data" do
+      real["foo"] = "bar"
 
-      scope = Hiera::Scope.new(real)
       scope["foo"].should == "bar"
     end
 
-    it "should get calling_class and calling_module from puppet scope" do
-      real = mock
-      resource = mock
-      resource.expects(:name).returns("Foo::Bar").twice
+    it "preserves the case of a string that is found" do
+      real["foo"] = "CAPITAL!"
+
+      scope["foo"].should == "CAPITAL!"
+    end
+
+    it "aliases $module_name as calling_module" do
+      real["module_name"] = "the_module"
+
+      scope["calling_module"].should == "the_module"
+    end
+
+    it "uses the name of the of the scope's class as the calling_class" do
+      real.source = Puppet::Resource::Type.new(:hostclass,
+                                               "testing",
+                                               :module_name => "the_module")
+
+      scope["calling_class"].should == "testing"
+    end
+
+    it "downcases the calling_class" do
+      real.source = Puppet::Resource::Type.new(:hostclass,
+                                               "UPPER CASE",
+                                               :module_name => "the_module")
+
+      scope["calling_class"].should == "upper case"
+    end
 
-      real.expects(:resource).returns(resource).twice
+    it "looks for the class which includes the defined type as the calling_class" do
+      parent = Puppet::Parser::Scope.new_for_test_harness("parent")
+      real.parent = parent
+      parent.source = Puppet::Resource::Type.new(:hostclass,
+                                                 "name_of_the_class_including_the_definition",
+                                                 :module_name => "class_module")
+      real.source = Puppet::Resource::Type.new(:definition,
+                                               "definition_name",
+                                               :module_name => "definition_module")
 
-      scope = Hiera::Scope.new(real)
-      scope["calling_class"].should == "foo::bar"
-      scope["calling_module"].should == "foo"
+      scope["calling_class"].should == "name_of_the_class_including_the_definition"
     end
   end
 
   describe "#include?" do
     it "should correctly report missing data" do
-      real = mock
-      real.expects(:lookupvar).with("foo").returns("")
+      real["foo"] = ""
 
-      scope = Hiera::Scope.new(real)
       scope.include?("foo").should == false
     end
 
     it "should always return true for calling_class and calling_module" do
-      real = mock
-      real.expects(:lookupvar).with("calling_class").never
-      real.expects(:lookupvar).with("calling_module").never
-
-      scope = Hiera::Scope.new(real)
       scope.include?("calling_class").should == true
       scope.include?("calling_module").should == true
     end

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

@@ -4,20 +4,23 @@ require 'spec_helper'
 describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
-  require 'puppet/rails'
-
   before :each do
     require 'puppet/indirector/catalog/active_record'
     setup_scratch_database
   end
 
+  after :each do
+    Puppet::Rails.teardown
+  end
+
   let :terminus do
     Puppet::Resource::Catalog::ActiveRecord.new
   end
 
   it "should issue a deprecation warning" do
     Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-    terminus
+
+    Puppet::Resource::Catalog::ActiveRecord.new
   end
 
   it "should be a subclass of the ActiveRecord terminus class" do

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

@@ -28,17 +28,12 @@ describe Puppet::Resource::Catalog::Compiler do
       node1 = stub 'node1', :merge => nil
       node2 = stub 'node2', :merge => nil
       compiler.stubs(:compile)
-      Puppet::Node.indirection.stubs(:find).with('node1', anything).returns(node1)
-      Puppet::Node.indirection.stubs(:find).with('node2', anything).returns(node2)
+      Puppet::Node.indirection.stubs(:find).with('node1', has_entry(:environment => anything)).returns(node1)
+      Puppet::Node.indirection.stubs(:find).with('node2', has_entry(:environment => anything)).returns(node2)
 
       compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node1', nil, :node => 'node1'))
       compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node2', nil, :node => 'node2'))
     end
-
-    it "should provide a method for determining if the catalog is networked" do
-      compiler = Puppet::Resource::Catalog::Compiler.new
-      compiler.should respond_to(:networked?)
-    end
   end
 
   describe "when finding catalogs" do
@@ -134,26 +129,6 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet::Parser::Compiler.expects(:compile).returns result
       @compiler.find(@request).should equal(result)
     end
-
-    it "should benchmark the compile process" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
-      @compiler.stubs(:networked?).returns(true)
-      @compiler.expects(:benchmark).with do |level, message|
-        level == :notice and message =~ /^Compiled catalog/
-      end
-      Puppet::Parser::Compiler.stubs(:compile)
-      @compiler.find(@request)
-    end
-
-    it "should log the benchmark result" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
-      @compiler.stubs(:networked?).returns(true)
-      Puppet::Parser::Compiler.stubs(:compile)
-
-      Puppet.expects(:notice).with { |msg| msg =~ /Compiled catalog/ }
-
-      @compiler.find(@request)
-    end
   end
 
   describe "when extracting facts from the request" do
@@ -180,7 +155,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       @facts.timestamp = Time.parse('2010-11-01')
       @now = Time.parse('2010-11-02')
-      Time.expects(:now).returns(@now)
+      Time.stubs(:now).returns(@now)
 
       @compiler.extract_facts_from_request(@request)
       @facts.timestamp.should == @now

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

@@ -137,7 +137,7 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     # a real fileserver initialized for testing.
     Puppet::FileServing::Metadata.
       indirection.stubs(:find).
-      with() { |*args| args[0] == options[:source].sub('puppet:///','') }.
+      with() { |*args| args[0] == options[:source].sub('puppet:///','') and args[1] == {:links => :manage, :environment => nil}}.
       returns(fake_fileserver_metadata)
 
     # I want a resource that all the file resources require and another

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

@@ -1,171 +1,175 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/rails'
 
 describe "Puppet::Node::Facts::InventoryActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   let(:terminus) { Puppet::Node::Facts::InventoryActiveRecord.new }
 
-  before :all do
-    require 'puppet/indirector/facts/inventory_active_record'
-  end
-
-  after :each do
-    Puppet::Node::Facts.indirection.reset_terminus_class
-  end
-
   before :each do
-    Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.cache_class = nil
-
+    require 'puppet/indirector/facts/inventory_active_record'
     Puppet::Node::Facts.indirection.terminus_class = :inventory_active_record
     setup_scratch_database
   end
 
-  it "should issue a deprecation warning" do
-    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-    terminus
-  end
-
-  describe "#save" do
-    let(:node) {
-      Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
-    }
-
-    let(:facts) {
-      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
-    }
-
-    it "should retry on ActiveRecord error" do
-      Puppet::Rails::InventoryNode.expects(:create).twice.raises(ActiveRecord::StatementInvalid).returns node
-
-      Puppet::Node::Facts.indirection.save(facts)
-    end
-
-    it "should use an existing node if possible" do
-      node.save
-      Puppet::Node::Facts.indirection.save(facts)
-
-      Puppet::Rails::InventoryNode.count.should == 1
-      Puppet::Rails::InventoryNode.first.should == node
-    end
-
-    it "should create a new node if one can't be found" do
-      # This test isn't valid if there are nodes to begin with
-      Puppet::Rails::InventoryNode.count.should == 0
-
-      Puppet::Node::Facts.indirection.save(facts)
-
-      Puppet::Rails::InventoryNode.count.should == 1
-      Puppet::Rails::InventoryNode.first.name.should == "foo"
-    end
-
-    it "should save the facts" do
-      Puppet::Node::Facts.indirection.save(facts)
-
-      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
-    end
-
-    it "should remove the previous facts for an existing node" do
-      facts = Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin")
-      Puppet::Node::Facts.indirection.save(facts)
-      bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
-      foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
-      Puppet::Node::Facts.indirection.save(bar_facts)
-      Puppet::Node::Facts.indirection.save(foo_facts)
-
-      Puppet::Node::Facts.indirection.find("bar").should == bar_facts
-      Puppet::Node::Facts.indirection.find("foo").should == foo_facts
-      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
-    end
+  after :each do
+    Puppet::Rails.teardown
   end
 
-  describe "#find" do
-    before do
-      @foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
-      @bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "30", "kernel" => "Linux")
-      Puppet::Node::Facts.indirection.save(@foo_facts)
-      Puppet::Node::Facts.indirection.save(@bar_facts)
-    end
-
-    it "should identify facts by node name" do
-      Puppet::Node::Facts.indirection.find("foo").should == @foo_facts
-    end
-
-    it "should return nil if no node instance can be found" do
-      Puppet::Node::Facts.indirection.find("non-existent node").should == nil
+  context "under Ruby 1.x", :if => (RUBY_VERSION[0] == '1' and can_use_scratch_database?) do
+    describe "#initialize" do
+      it "should issue a deprecation warning" do
+        Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
+        terminus
+      end
+    end
+
+    describe "#save" do
+      let(:node) {
+        Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
+      }
+
+      let(:facts) {
+        Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
+      }
+
+      it "should retry on ActiveRecord error" do
+        Puppet::Rails::InventoryNode.expects(:create).twice.raises(ActiveRecord::StatementInvalid).returns node
+
+        Puppet::Node::Facts.indirection.save(facts)
+      end
+
+      it "should use an existing node if possible" do
+        node.save
+        Puppet::Node::Facts.indirection.save(facts)
+
+        Puppet::Rails::InventoryNode.count.should == 1
+        Puppet::Rails::InventoryNode.first.should == node
+      end
+
+      it "should create a new node if one can't be found" do
+        # This test isn't valid if there are nodes to begin with
+        Puppet::Rails::InventoryNode.count.should == 0
+
+        Puppet::Node::Facts.indirection.save(facts)
+
+        Puppet::Rails::InventoryNode.count.should == 1
+        Puppet::Rails::InventoryNode.first.name.should == "foo"
+      end
+
+      it "should save the facts" do
+        Puppet::Node::Facts.indirection.save(facts)
+
+        Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
+      end
+
+      it "should remove the previous facts for an existing node" do
+        facts = Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin")
+        Puppet::Node::Facts.indirection.save(facts)
+        bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
+        foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
+        Puppet::Node::Facts.indirection.save(bar_facts)
+        Puppet::Node::Facts.indirection.save(foo_facts)
+
+        Puppet::Node::Facts.indirection.find("bar").should == bar_facts
+        Puppet::Node::Facts.indirection.find("foo").should == foo_facts
+        Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
+      end
+    end
+
+    describe "#find" do
+      before do
+        @foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
+        @bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "30", "kernel" => "Linux")
+        Puppet::Node::Facts.indirection.save(@foo_facts)
+        Puppet::Node::Facts.indirection.save(@bar_facts)
+      end
+
+      it "should identify facts by node name" do
+        Puppet::Node::Facts.indirection.find("foo").should == @foo_facts
+      end
+
+      it "should return nil if no node instance can be found" do
+        Puppet::Node::Facts.indirection.find("non-existent node").should == nil
+      end
+    end
+
+    describe "#search" do
+      def search_request(conditions)
+        Puppet::Indirector::Request.new(:facts, :search, nil, nil, conditions)
+      end
+
+      before :each do
+        @now = Time.now
+        @foo = Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "uptime_days" => "30")
+        @bar = Puppet::Node::Facts.new("bar", "fact1" => "value1", "uptime_days" => "60")
+        @baz = Puppet::Node::Facts.new("baz", "fact1" => "value2", "fact2" => "value1", "uptime_days" => "90")
+        @bat = Puppet::Node::Facts.new("bat")
+        @foo.timestamp = @now - 3600*1
+        @bar.timestamp = @now - 3600*3
+        @baz.timestamp = @now - 3600*5
+        @bat.timestamp = @now - 3600*7
+        [@foo, @bar, @baz, @bat].each {|facts| Puppet::Node::Facts.indirection.save(facts)}
+      end
+
+      it "should return node names that match 'equal' constraints" do
+        request = search_request('facts.fact1.eq' => 'value1',
+                                 'facts.fact2.eq' => 'value2')
+        terminus.search(request).should == ["foo"]
+      end
+
+      it "should return node names that match 'not equal' constraints" do
+        request = search_request('facts.fact1.ne' => 'value2')
+        terminus.search(request).should == ["bar","foo"]
+      end
+
+      it "should return node names that match strict inequality constraints" do
+        request = search_request('facts.uptime_days.gt' => '20',
+                                 'facts.uptime_days.lt' => '70')
+        terminus.search(request).should == ["bar","foo"]
+      end
+
+      it "should return node names that match non-strict inequality constraints" do
+        request = search_request('facts.uptime_days.ge' => '30',
+                                 'facts.uptime_days.le' => '60')
+        terminus.search(request).should == ["bar","foo"]
+      end
+
+      it "should return node names whose facts are within a given timeframe" do
+        request = search_request('meta.timestamp.ge' => @now - 3600*5,
+                                 'meta.timestamp.le' => @now - 3600*1)
+        terminus.search(request).should == ["bar","baz","foo"]
+      end
+
+      it "should return node names whose facts are from a specific time" do
+        request = search_request('meta.timestamp.eq' => @now - 3600*3)
+        terminus.search(request).should == ["bar"]
+      end
+
+      it "should return node names whose facts are not from a specific time" do
+        request = search_request('meta.timestamp.ne' => @now - 3600*1)
+        terminus.search(request).should == ["bar","bat","baz"]
+      end
+
+      it "should perform strict searches on nodes by timestamp" do
+        request = search_request('meta.timestamp.gt' => @now - 3600*5,
+                                 'meta.timestamp.lt' => @now - 3600*1)
+        terminus.search(request).should == ["bar"]
+      end
+
+      it "should search nodes based on both facts and timestamp values" do
+        request = search_request('facts.uptime_days.gt' => '45',
+                                 'meta.timestamp.lt'    => @now - 3600*4)
+        terminus.search(request).should == ["baz"]
+      end
     end
   end
 
-  describe "#search" do
-    def search_request(conditions)
-      Puppet::Indirector::Request.new(:facts, :search, nil, nil, conditions)
-    end
-
-    before :each do
-      @now = Time.now
-      @foo = Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "uptime_days" => "30")
-      @bar = Puppet::Node::Facts.new("bar", "fact1" => "value1", "uptime_days" => "60")
-      @baz = Puppet::Node::Facts.new("baz", "fact1" => "value2", "fact2" => "value1", "uptime_days" => "90")
-      @bat = Puppet::Node::Facts.new("bat")
-      @foo.timestamp = @now - 3600*1
-      @bar.timestamp = @now - 3600*3
-      @baz.timestamp = @now - 3600*5
-      @bat.timestamp = @now - 3600*7
-      [@foo, @bar, @baz, @bat].each {|facts| Puppet::Node::Facts.indirection.save(facts)}
-    end
-
-    it "should return node names that match 'equal' constraints" do
-      request = search_request('facts.fact1.eq' => 'value1',
-                               'facts.fact2.eq' => 'value2')
-      terminus.search(request).should == ["foo"]
-    end
-
-    it "should return node names that match 'not equal' constraints" do
-      request = search_request('facts.fact1.ne' => 'value2')
-      terminus.search(request).should == ["bar","foo"]
-    end
-
-    it "should return node names that match strict inequality constraints" do
-      request = search_request('facts.uptime_days.gt' => '20',
-                               'facts.uptime_days.lt' => '70')
-      terminus.search(request).should == ["bar","foo"]
-    end
-
-    it "should return node names that match non-strict inequality constraints" do
-      request = search_request('facts.uptime_days.ge' => '30',
-                               'facts.uptime_days.le' => '60')
-      terminus.search(request).should == ["bar","foo"]
-    end
-
-    it "should return node names whose facts are within a given timeframe" do
-      request = search_request('meta.timestamp.ge' => @now - 3600*5,
-                               'meta.timestamp.le' => @now - 3600*1)
-      terminus.search(request).should == ["bar","baz","foo"]
-    end
-
-    it "should return node names whose facts are from a specific time" do
-      request = search_request('meta.timestamp.eq' => @now - 3600*3)
-      terminus.search(request).should == ["bar"]
-    end
-
-    it "should return node names whose facts are not from a specific time" do
-      request = search_request('meta.timestamp.ne' => @now - 3600*1)
-      terminus.search(request).should == ["bar","bat","baz"]
-    end
-
-    it "should perform strict searches on nodes by timestamp" do
-      request = search_request('meta.timestamp.gt' => @now - 3600*5,
-                               'meta.timestamp.lt' => @now - 3600*1)
-      terminus.search(request).should == ["bar"]
-    end
-
-    it "should search nodes based on both facts and timestamp values" do
-      request = search_request('facts.uptime_days.gt' => '45',
-                               'meta.timestamp.lt'    => @now - 3600*4)
-      terminus.search(request).should == ["baz"]
+  context "under Ruby 2.x", :if => (RUBY_VERSION[0] == '2' and can_use_scratch_database?) do
+    describe "#initialize" do
+      it "should raise error under Ruby 2" do
+        lambda { terminus }.should raise_error(Puppet::Error, /Ruby 2/)
+      end
     end
   end
 end
-