puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/indirector/rest_spec.rb

@@ -101,6 +101,7 @@ describe Puppet::Indirector::REST do
   end
 
   after :all do
+    Puppet::TestModel.indirection.delete
     # Remove the class, unlinking it from the rest of the system.
     Puppet.send(:remove_const, :TestModel)
   end

data/spec/unit/indirector_spec.rb

@@ -118,9 +118,9 @@ describe Puppet::Indirector, "when registering an indirection" do
     @indirection = @thingie.indirects :first, :some => :options
   end
 
-  it "should extend the class with the Format Handler" do
+  it "should extend the class to handle serialization" do
     @indirection = @thingie.indirects :first
-    @thingie.singleton_class.ancestors.should be_include(Puppet::Network::FormatHandler)
+    @thingie.should respond_to(:convert_from)
   end
 
   after do

data/spec/unit/interface/option_builder_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'puppet/interface'
 
 describe Puppet::Interface::OptionBuilder do

data/spec/unit/interface/option_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'puppet/interface'
 
 describe Puppet::Interface::Option do

data/spec/unit/interface_spec.rb

@@ -24,11 +24,11 @@ describe Puppet::Interface do
     end
 
     it "should raise an exception when the requested version is unavailable" do
-      expect { subject[:huzzah, '17.0.0'] }.to raise_error, Puppet::Error
+      expect { subject[:huzzah, '17.0.0'] }.to raise_error(Puppet::Error, /Could not find version/)
     end
 
     it "should raise an exception when the requested face doesn't exist" do
-      expect { subject[:burrble_toot, :current] }.to raise_error, Puppet::Error
+      expect { subject[:burrble_toot, :current] }.to raise_error(Puppet::Error, /Could not find Puppet Face/)
     end
 
     describe "version matching" do

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -42,6 +42,17 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
 
   let(:remote_dependency_info) do
     {
+      "pmtacceptance/apache" => [
+        { "dependencies" => [],
+          "version"      => "1.0.0-alpha",
+          "file"         => "/pmtacceptance-apache-1.0.0-alpha.tar.gz" },
+        { "dependencies" => [],
+          "version"      => "1.0.0-beta",
+          "file"         => "/pmtacceptance-apache-1.0.0-beta.tar.gz" },
+        { "dependencies" => [],
+          "version"      => "1.0.0-rc1",
+          "file"         => "/pmtacceptance-apache-1.0.0-rc1.tar.gz" },
+      ],
       "pmtacceptance/stdlib" => [
         { "dependencies" => [],
           "version"      => "0.0.1",
@@ -49,9 +60,15 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
         { "dependencies" => [],
           "version"      => "0.0.2",
           "file"         => "/pmtacceptance-stdlib-0.0.2.tar.gz" },
+        { "dependencies" => [],
+          "version"      => "1.0.0-pre",
+          "file"         => "/pmtacceptance-stdlib-1.0.0-pre.tar.gz" },
         { "dependencies" => [],
           "version"      => "1.0.0",
-          "file"         => "/pmtacceptance-stdlib-1.0.0.tar.gz" }
+          "file"         => "/pmtacceptance-stdlib-1.0.0.tar.gz" },
+        { "dependencies" => [],
+          "version"      => "1.5.0-pre",
+          "file"         => "/pmtacceptance-stdlib-1.5.0-pre.tar.gz" },
       ],
       "pmtacceptance/java" => [
         { "dependencies" => [["pmtacceptance/stdlib", ">= 0.0.1"]],
@@ -97,7 +114,7 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
         raise_error(ArgumentError, "Could not install module with invalid name: puppet")
     end
 
-    it "should install the requested module" do
+    it "should install the current stable version of the requested module" do
       Puppet::ModuleTool::Applications::Unpacker.expects(:new).
         with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
         returns(unpacker)
@@ -107,6 +124,36 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
       results[:installed_modules][0][:version][:vstring].should == "1.0.0"
     end
 
+    it "should install the most recent version of requested module in the absence of a stable version" do
+      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+        with('/fake_cache/pmtacceptance-apache-1.0.0-rc1.tar.gz', options).
+        returns(unpacker)
+      results = installer_class.run('pmtacceptance-apache', forge, install_dir, options)
+      results[:installed_modules].length == 1
+      results[:installed_modules][0][:module].should == "pmtacceptance-apache"
+      results[:installed_modules][0][:version][:vstring].should == "1.0.0-rc1"
+    end
+
+    it "should install the most recent stable version of requested module for the requested version range" do
+      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+        with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options.merge(:version => '1.x')).
+        returns(unpacker)
+      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options.merge(:version => '1.x'))
+      results[:installed_modules].length == 1
+      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
+      results[:installed_modules][0][:version][:vstring].should == "1.0.0"
+    end
+
+    it "should install the most recent version of requested module for the requested version range in the absence of a stable version" do
+      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+      with('/fake_cache/pmtacceptance-stdlib-1.5.0-pre.tar.gz', options.merge(:version => '1.5.0-pre')).
+        returns(unpacker)
+      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options.merge(:version => '1.5.0-pre'))
+      results[:installed_modules].length == 1
+      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
+      results[:installed_modules][0][:version][:vstring].should == "1.5.0-pre"
+    end
+
     context "should check the target directory" do
       let(:installer) do
         installer_class.new('pmtacceptance-stdlib', forge, install_dir, options)

data/spec/unit/module_tool/metadata_spec.rb

@@ -8,4 +8,17 @@ describe Puppet::ModuleTool::Metadata do
       metadata.license.should == "Apache License, Version 2.0"
     end
   end
+
+  describe :to_hash do
+    it 'should merge extra_data in' do
+      metadata = Puppet::ModuleTool::Metadata.new
+      metadata.extra_metadata = {
+        'checksums' => 'badsums',
+        'special_key' => 'special'
+      }
+      meta_hash = metadata.to_hash
+      meta_hash['special_key'].should == 'special'
+      meta_hash['checksums'].should == {}
+    end
+  end
 end

data/spec/unit/network/authstore_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::Network::AuthStore::Declaration do
     end
 
     (1..3).each { |n|
-      describe "when the pattern is a IP mask with #{n} numeric segments and a *" do
+      describe "when the pattern is an IP mask with #{n} numeric segments and a *" do
         before :each do
           @ip_pattern = ip.split('.')[0,n].join('.')+'.*'
           @declaration = Puppet::Network::AuthStore::Declaration.new(:allow_ip,@ip_pattern)

data/spec/unit/network/format_handler_spec.rb

@@ -3,209 +3,33 @@ require 'spec_helper'
 
 require 'puppet/network/format_handler'
 
-class FormatTester
-  extend Puppet::Network::FormatHandler
-end
-
 describe Puppet::Network::FormatHandler do
-  after do
-    formats = Puppet::Network::FormatHandler.instance_variable_get("@formats")
-    formats.each do |name, format|
-      formats.delete(name) unless format.is_a?(Puppet::Network::Format)
-    end
+  before(:each) do
+    @saved_formats = Puppet::Network::FormatHandler.instance_variable_get(:@formats).dup
+    Puppet::Network::FormatHandler.instance_variable_set(:@formats, {})
   end
 
-  it "should be able to list supported formats" do
-    FormatTester.should respond_to(:supported_formats)
+  after(:each) do
+    Puppet::Network::FormatHandler.instance_variable_set(:@formats, @saved_formats)
   end
 
-  it "should include all supported formats" do
-    one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-    two = stub 'supported', :supported? => false, :name => :two, :weight => 1
-    three = stub 'supported', :supported? => true, :name => :three, :weight => 1
-    four = stub 'supported', :supported? => false, :name => :four, :weight => 1
-    Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two, :three, :four]
-    Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-    Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-    Puppet::Network::FormatHandler.stubs(:format).with(:three).returns three
-    Puppet::Network::FormatHandler.stubs(:format).with(:four).returns four
-    result = FormatTester.supported_formats
-    result.length.should == 2
-    result.should be_include(:one)
-    result.should be_include(:three)
-  end
-
-  it "should return the supported formats in decreasing order of weight" do
-    one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-    two = stub 'supported', :supported? => true, :name => :two, :weight => 6
-    three = stub 'supported', :supported? => true, :name => :three, :weight => 2
-    four = stub 'supported', :supported? => true, :name => :four, :weight => 8
-    Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two, :three, :four]
-    Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-    Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-    Puppet::Network::FormatHandler.stubs(:format).with(:three).returns three
-    Puppet::Network::FormatHandler.stubs(:format).with(:four).returns four
-    FormatTester.supported_formats.should == [:four, :two, :three, :one]
-  end
-
-
-  describe "with a preferred serialization format setting" do
-    before do
-      one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-      two = stub 'supported', :supported? => true, :name => :two, :weight => 6
-      Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two]
-      Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-      Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-    end
-    describe "that is supported" do
-      before do
-        Puppet[:preferred_serialization_format] = :one
-      end
-      it "should return the preferred serialization format first" do
-        FormatTester.supported_formats.should == [:one, :two]
-      end
-    end
-    describe "that is not supported" do
-      before do
-        Puppet[:preferred_serialization_format] = :unsupported
-      end
-      it "should still return the default format first" do
-        FormatTester.supported_formats.should == [:two, :one]
-      end
-      it "should log a debug message" do
-        Puppet.expects(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        Puppet.expects(:debug).with("FormatTester supports formats: one two; using two")
-        FormatTester.supported_formats
+  describe "when creating formats" do
+    it "should instance_eval any block provided when creating a format" do
+      format = Puppet::Network::FormatHandler.create(:test_format) do
+        def asdfghjkl; end
       end
+      format.should respond_to(:asdfghjkl)
     end
   end
 
-  it "should return the first format as the default format" do
-    FormatTester.expects(:supported_formats).returns [:one, :two]
-    FormatTester.default_format.should == :one
-  end
-
-  it "should be able to use a protected format for better logging on errors" do
-    Puppet::Network::FormatHandler.should respond_to(:protected_format)
-  end
-
-  it "should delegate all methods from the informative format to the specified format" do
-    format = mock 'format'
-    format.stubs(:name).returns(:myformat)
-    Puppet::Network::FormatHandler.expects(:format).twice.with(:myformat).returns format
-
-    format.expects(:render).with("foo").returns "yay"
-    Puppet::Network::FormatHandler.protected_format(:myformat).render("foo").should == "yay"
-  end
-
-  it "should provide better logging if a failure is encountered when delegating from the informative format to the real format" do
-    format = mock 'format'
-    format.stubs(:name).returns(:myformat)
-    Puppet::Network::FormatHandler.expects(:format).twice.with(:myformat).returns format
-
-    format.expects(:render).with("foo").raises "foo"
-    lambda { Puppet::Network::FormatHandler.protected_format(:myformat).render("foo") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-  end
-
-  it "should raise an error if we couldn't find a format by name or mime-type" do
-    Puppet::Network::FormatHandler.stubs(:format).with(:myformat).returns nil
-    lambda { Puppet::Network::FormatHandler.protected_format(:myformat) }.should raise_error
-  end
-
-  describe "when using formats" do
-    before do
-      @format = mock 'format'
-      @format.stubs(:supported?).returns true
-      @format.stubs(:name).returns :my_format
-      Puppet::Network::FormatHandler.stubs(:format).with(:my_format).returns @format
-      Puppet::Network::FormatHandler.stubs(:mime).with("text/myformat").returns @format
-      Puppet::Network::Format.stubs(:===).returns false
-      Puppet::Network::Format.stubs(:===).with(@format).returns true
-    end
-
-    it "should be able to test whether a format is supported" do
-      FormatTester.should respond_to(:support_format?)
-    end
-
-    it "should use the Format to determine whether a given format is supported" do
-      @format.expects(:supported?).with(FormatTester)
-      FormatTester.support_format?(:my_format)
-    end
-
-    it "should be able to convert from a given format" do
-      FormatTester.should respond_to(:convert_from)
-    end
-
-    it "should call the format-specific converter when asked to convert from a given format" do
-      @format.expects(:intern).with(FormatTester, "mydata")
-      FormatTester.convert_from(:my_format, "mydata")
-    end
-
-    it "should call the format-specific converter when asked to convert from a given format by mime-type" do
-      @format.expects(:intern).with(FormatTester, "mydata")
-      FormatTester.convert_from("text/myformat", "mydata")
-    end
-
-    it "should call the format-specific converter when asked to convert from a given format by format instance" do
-      @format.expects(:intern).with(FormatTester, "mydata")
-      FormatTester.convert_from(@format, "mydata")
-    end
-
-    it "should raise a FormatError when an exception is encountered when converting from a format" do
-      @format.expects(:intern).with(FormatTester, "mydata").raises "foo"
-      lambda { FormatTester.convert_from(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-    end
-
-    it "should be able to use a specific hook for converting into multiple instances" do
-      @format.expects(:intern_multiple).with(FormatTester, "mydata")
-
-      FormatTester.convert_from_multiple(:my_format, "mydata")
-    end
-
-    it "should raise a FormatError when an exception is encountered when converting multiple items from a format" do
-      @format.expects(:intern_multiple).with(FormatTester, "mydata").raises "foo"
-      lambda { FormatTester.convert_from_multiple(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-    end
-
-    it "should be able to use a specific hook for rendering multiple instances" do
-      @format.expects(:render_multiple).with("mydata")
-
-      FormatTester.render_multiple(:my_format, "mydata")
-    end
-
-    it "should raise a FormatError when an exception is encountered when rendering multiple items into a format" do
-      @format.expects(:render_multiple).with("mydata").raises "foo"
-      lambda { FormatTester.render_multiple(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-    end
-  end
-
-  describe "when managing formats" do
-    it "should have a method for defining a new format" do
-      Puppet::Network::FormatHandler.should respond_to(:create)
-    end
-
-    it "should create a format instance when asked" do
-      format = stub 'format', :name => :foo
-      Puppet::Network::Format.expects(:new).with(:foo).returns format
-      Puppet::Network::FormatHandler.create(:foo)
-    end
-
-    it "should instance_eval any block provided when creating a format" do
-      format = stub 'format', :name => :instance_eval
-      format.expects(:yayness)
-      Puppet::Network::Format.expects(:new).returns format
-      Puppet::Network::FormatHandler.create(:instance_eval) do
-        yayness
-      end
-    end
+  describe "when retrieving formats" do
+    let!(:format) { Puppet::Network::FormatHandler.create(:the_format, :extension => "foo", :mime => "foo/bar") }
 
     it "should be able to retrieve a format by name" do
-      format = Puppet::Network::FormatHandler.create(:by_name)
-      Puppet::Network::FormatHandler.format(:by_name).should equal(format)
+      Puppet::Network::FormatHandler.format(:the_format).should equal(format)
     end
 
     it "should be able to retrieve a format by extension" do
-      format = Puppet::Network::FormatHandler.create(:by_extension, :extension => "foo")
       Puppet::Network::FormatHandler.format_by_extension("foo").should equal(format)
     end
 
@@ -213,123 +37,50 @@ describe Puppet::Network::FormatHandler do
       Puppet::Network::FormatHandler.format_by_extension("yayness").should be_nil
     end
 
-    it "should be able to retrieve formats by name irrespective of case and class" do
-      format = Puppet::Network::FormatHandler.create(:by_name)
-      Puppet::Network::FormatHandler.format(:By_Name).should equal(format)
+    it "should be able to retrieve formats by name irrespective of case" do
+      Puppet::Network::FormatHandler.format(:The_Format).should equal(format)
     end
 
     it "should be able to retrieve a format by mime type" do
-      format = Puppet::Network::FormatHandler.create(:by_name, :mime => "foo/bar")
       Puppet::Network::FormatHandler.mime("foo/bar").should equal(format)
     end
 
     it "should be able to retrieve a format by mime type irrespective of case" do
-      format = Puppet::Network::FormatHandler.create(:by_name, :mime => "foo/bar")
       Puppet::Network::FormatHandler.mime("Foo/Bar").should equal(format)
     end
-
-    it "should be able to return all formats" do
-      one = stub 'one', :name => :one
-      two = stub 'two', :name => :two
-      Puppet::Network::Format.expects(:new).with(:one).returns(one)
-      Puppet::Network::Format.expects(:new).with(:two).returns(two)
-
-      Puppet::Network::FormatHandler.create(:one)
-      Puppet::Network::FormatHandler.create(:two)
-
-      list = Puppet::Network::FormatHandler.formats
-      list.should be_include(:one)
-      list.should be_include(:two)
-    end
   end
 
-  describe "when an instance" do
-    it "should be able to test whether a format is supported" do
-      FormatTester.new.should respond_to(:support_format?)
+  describe "#most_suitable_format_for" do
+    before :each do
+      Puppet::Network::FormatHandler.create(:one, :extension => "foo", :mime => "text/one")
+      Puppet::Network::FormatHandler.create(:two, :extension => "bar", :mime => "text/two")
     end
 
-    it "should be able to convert to a given format" do
-      FormatTester.new.should respond_to(:render)
-    end
+    let(:format_one) { Puppet::Network::FormatHandler.format(:one) }
+    let(:format_two) { Puppet::Network::FormatHandler.format(:two) }
 
-    it "should be able to get a format mime-type" do
-      FormatTester.new.should respond_to(:mime)
+    def suitable_in_setup_formats(accepted)
+      Puppet::Network::FormatHandler.most_suitable_format_for(accepted, [:one, :two])
     end
 
-    it "should raise a FormatError when a rendering error is encountered" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      tester = FormatTester.new
-      format.expects(:render).with(tester).raises "eh"
-
-      lambda { tester.render(:foo) }.should raise_error(Puppet::Network::FormatHandler::FormatError)
+    it "finds no format when none are acceptable" do
+      suitable_in_setup_formats(["three"]).should be_nil
     end
 
-    it "should call the format-specific converter when asked to convert to a given format" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
-
-      tester.render(:foo).should == "foo"
+    it "skips unsupported, but accepted, formats" do
+      suitable_in_setup_formats(["three", "two"]).should == format_two
     end
 
-    it "should call the format-specific converter when asked to convert to a given format by mime-type" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-      Puppet::Network::FormatHandler.stubs(:mime).with("text/foo").returns format
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
-
-      tester.render("text/foo").should == "foo"
+    it "gives the first acceptable and suitable format" do
+      suitable_in_setup_formats(["three", "one", "two"]).should == format_one
     end
 
-    it "should call the format converter when asked to convert to a given format instance" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-      Puppet::Network::Format.stubs(:===).with(format).returns(true)
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      tester = FormatTester.new
-      format.expects(:render).with(tester).returns "foo"
-
-      tester.render(format).should == "foo"
+    it "allows specifying acceptable formats by mime type" do
+      suitable_in_setup_formats(["text/one"]).should == format_one
     end
 
-    it "should render to the default format if no format is provided when rendering" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      FormatTester.expects(:default_format).returns :foo
-      tester = FormatTester.new
-
-      format.expects(:render).with(tester)
-      tester.render
-    end
-
-    it "should call the format-specific converter when asked for the mime-type of a given format" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      tester = FormatTester.new
-      format.expects(:mime).returns "text/foo"
-
-      tester.mime(:foo).should == "text/foo"
-    end
-
-    it "should return the default format mime-type if no format is provided" do
-      format = stub 'rendering format', :supported? => true, :name => :foo
-      Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-      FormatTester.expects(:default_format).returns :foo
-      tester = FormatTester.new
-
-      format.expects(:mime).returns "text/foo"
-      tester.mime.should == "text/foo"
+    it "allows specifying acceptable formats by canonical name" do
+      suitable_in_setup_formats([:one]).should == format_one
     end
   end
 end