puppet 3.6.2 → 3.7.0

data/spec/unit/configurer_spec.rb

@@ -12,10 +12,6 @@ describe Puppet::Configurer do
     Puppet[:report] = true
   end
 
-  it "should include the Plugin Handler module" do
-    Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::PluginHandler)
-  end
-
   it "should include the Fact Handler module" do
     Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
   end

data/spec/unit/defaults_spec.rb

@@ -41,4 +41,34 @@ describe "Defaults" do
       end
     end
   end
+
+  describe 'cfacter' do
+
+    before :each do
+      Facter.reset
+    end
+
+    it 'should default to false' do
+      Puppet.settings[:cfacter].should be_false
+    end
+
+    it 'should raise an error if cfacter is not installed' do
+      Puppet.features.stubs(:cfacter?).returns false
+      lambda { Puppet.settings[:cfacter] = true }.should raise_exception ArgumentError, 'cfacter version 0.2.0 or later is not installed.'
+    end
+
+    it 'should raise an error if facter has already evaluated facts' do
+      Facter[:facterversion]
+      Puppet.features.stubs(:cfacter?).returns true
+      lambda { Puppet.settings[:cfacter] = true }.should raise_exception ArgumentError, 'facter has already evaluated facts.'
+    end
+
+    it 'should initialize cfacter when set to true' do
+      Puppet.features.stubs(:cfacter?).returns true
+      CFacter = mock
+      CFacter.stubs(:initialize)
+      Puppet.settings[:cfacter] = true
+    end
+
+  end
 end

data/spec/unit/face/config_spec.rb

@@ -92,6 +92,7 @@ basemodulepath = #{File.expand_path("/some/base")}
     end
 
     it "prints the default configured env settings for an env that does not exist" do
+      pending "This case no longer exists because Application will through an error before we even get here because of the non-existent environment"
       Puppet[:environment] = 'doesnotexist'
 
       FS.overlay(
@@ -125,7 +126,7 @@ basemodulepath = #{File.expand_path("/some/base")}
         CONF
       end
 
-      it_behaves_like :config_printing_a_section
+      it_behaves_like :config_printing_a_section, nil
     end
 
     context "from master section" do

data/spec/unit/face/module/build_spec.rb

@@ -25,7 +25,7 @@ describe "puppet module build" do
     it "if current directory or parents contain no module root, should return exception" do
       Dir.expects(:pwd).returns('/a/b/c')
       Puppet::ModuleTool.expects(:find_module_root).returns(nil)
-      expect { subject.build }.to raise_error RuntimeError, "Unable to find module root at /a/b/c or parent directories"
+      expect { subject.build }.to raise_error RuntimeError, "Unable to find metadata.json or Modulefile in module root /a/b/c or parent directories. See <http://links.puppetlabs.com/modulefile> for required file format."
     end
   end
 
@@ -39,7 +39,7 @@ describe "puppet module build" do
 
     it "if path is not a module root should raise exception" do
       Puppet::ModuleTool.expects(:is_module_root?).with('/a/b/c').returns(false)
-      expect { subject.build('/a/b/c') }.to raise_error RuntimeError, "Unable to find module root at /a/b/c"
+      expect { subject.build('/a/b/c') }.to raise_error RuntimeError, "Unable to find metadata.json or Modulefile in module root /a/b/c. See <http://links.puppetlabs.com/modulefile> for required file format."
     end
   end
 

data/spec/unit/face/module/install_spec.rb

@@ -7,19 +7,19 @@ describe "puppet module install" do
 
   describe "action" do
     let(:name)        { stub(:name) }
-    let(:target_dir)  { stub(:target_dir) }
-    let(:target_path) { stub(:target_path) }
-    let(:install_dir) { stub(:install_dir) }
+    let(:target_dir)  { tmpdir('module install face action') }
     let(:options)     { { :target_dir => target_dir } }
 
     it 'should invoke the Installer app' do
-      args = [ name, install_dir, options ]
-
       Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with do |*args|
+        mod, target, opts = args
 
-      Pathname.expects(:new).with(target_dir).returns(target_path)
-      Puppet::ModuleTool::InstallDirectory.expects(:new).with(target_path).returns(install_dir)
-      Puppet::ModuleTool::Applications::Installer.expects(:run).with(*args)
+        expect(mod).to eql(name)
+        expect(opts).to eql(options)
+        expect(target).to be_a(Puppet::ModuleTool::InstallDirectory)
+        expect(target.target).to eql(Pathname.new(target_dir))
+      end
 
       Puppet::Face[:module, :current].install(name, options)
     end

data/spec/unit/face/parser_spec.rb

@@ -8,58 +8,96 @@ describe Puppet::Face[:parser, :current] do
 
   let(:parser) { Puppet::Face[:parser, :current] }
 
-  context "from an interactive terminal" do
-    before :each do
-      from_an_interactive_terminal
+  context "validate" do
+    context "from an interactive terminal" do
+      before :each do
+        from_an_interactive_terminal
+      end
+
+      it "validates the configured site manifest when no files are given" do
+        manifest = file_containing('site.pp', "{ invalid =>")
+
+        configured_environment = Puppet::Node::Environment.create(:default, [], manifest)
+        Puppet.override(:current_environment => configured_environment) do
+          expect { parser.validate() }.to exit_with(1)
+        end
+      end
+
+      it "validates the given file" do
+        manifest = file_containing('site.pp', "{ invalid =>")
+
+        expect { parser.validate(manifest) }.to exit_with(1)
+      end
+
+      it "runs error free when there are no validation errors" do
+        manifest = file_containing('site.pp', "notify { valid: }")
+
+        parser.validate(manifest)
+      end
+
+      it "reports missing files" do
+        expect do
+          parser.validate("missing.pp")
+        end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
+      end
+
+      it "parses supplied manifest files in the context of a directory environment" do
+        manifest = file_containing('test.pp', "{ invalid =>")
+
+        env = Puppet::Node::Environment.create(:special, [])
+        env_loader = Puppet::Environments::Static.new(env)
+        Puppet.override({:environments => env_loader, :current_environment => env}) do
+          expect { parser.validate(manifest) }.to exit_with(1)
+        end
+
+        expect(@logs.join).to match(/environment special.*Syntax error at '\{'/)
+      end
+
     end
 
-    it "validates the configured site manifest when no files are given" do
-      manifest = file_containing('site.pp', "{ invalid =>")
+    it "validates the contents of STDIN when no files given and STDIN is not a tty" do
+      from_a_piped_input_of("{ invalid =>")
 
-      configured_environment = Puppet::Node::Environment.create(:default, [], manifest)
-      Puppet.override(:current_environment => configured_environment) do
+      Puppet.override(:current_environment => Puppet::Node::Environment.create(:special, [])) do
         expect { parser.validate() }.to exit_with(1)
       end
     end
+  end
 
-    it "validates the given file" do
-      manifest = file_containing('site.pp', "{ invalid =>")
-
-      expect { parser.validate(manifest) }.to exit_with(1)
+  context "dump" do
+    it "prints the AST of the passed expression" do
+      expect(parser.dump({ :e => 'notice hi' })).to eq("(invoke notice hi)\n")
     end
 
-    it "runs error free when there are no validation errors" do
-      manifest = file_containing('site.pp', "notify { valid: }")
+    it "prints the AST of the code read from the passed files" do
+      first_manifest = file_containing('site.pp', "notice hi")
+      second_manifest = file_containing('site2.pp', "notice bye")
 
-      parser.validate(manifest)
+      output = parser.dump(first_manifest, second_manifest)
+
+      expect(output).to match(/site\.pp.*\(invoke notice hi\)/)
+      expect(output).to match(/site2\.pp.*\(invoke notice bye\)/)
     end
 
-    it "reports missing files" do
-      expect do
-        parser.validate("missing.pp")
-      end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
+    it "informs the user of files that don't exist" do
+      expect(parser.dump('does_not_exist_here.pp')).to match(/did not exist:\s*does_not_exist_here\.pp/m)
     end
 
-    it "parses supplied manifest files in the context of a directory environment" do
-      manifest = file_containing('test.pp', "{ invalid =>")
+    it "prints the AST of STDIN when no files given and STDIN is not a tty" do
+      from_a_piped_input_of("notice hi")
 
-      env_loader = Puppet::Environments::Static.new(
-        Puppet::Node::Environment.create(:special, [])
-      )
-      Puppet.override(:environments => env_loader) do
-        Puppet[:environment] = 'special'
-        expect { parser.validate(manifest) }.to exit_with(1)
+      Puppet.override(:current_environment => Puppet::Node::Environment.create(:special, [])) do
+        expect(parser.dump()).to eq("(invoke notice hi)\n")
       end
-
-      expect(@logs.join).to match(/environment special.*Syntax error at '\{'/)
     end
 
-  end
-
-  it "validates the contents of STDIN when no files given and STDIN is not a tty" do
-    from_a_piped_input_of("{ invalid =>")
+    it "logs an error if the input cannot be parsed" do
+      output = parser.dump({ :e => '{ invalid =>' })
 
-    expect { parser.validate() }.to exit_with(1)
+      expect(output).to eq("")
+      expect(@logs[0].message).to eq("Syntax error at end of file")
+      expect(@logs[0].level).to eq(:err)
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/file_bucket/file_spec.rb

@@ -14,7 +14,7 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
   end
 
   it "accepts s and pson" do
-   expect(Puppet::FileBucket::File.supported_formats).to include(:s, :pson)
+    expect(Puppet::FileBucket::File.supported_formats).to include(:s, :pson)
   end
 
   describe "making round trips through network formats" do
@@ -34,7 +34,7 @@ describe Puppet::FileBucket::File, :uses_checksums => true do
   end
 
   it "should require contents to be a string" do
-    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String, got a Fixnum$/)
+    expect { Puppet::FileBucket::File.new(5) }.to raise_error(ArgumentError, /contents must be a String or Pathname, got a Fixnum$/)
   end
 
   it "should complain about options other than :bucket_path" do

data/spec/unit/file_system/uniquefile_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe Puppet::FileSystem::Uniquefile do
+  it "makes the name of the file available" do
+    Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+      expect(file.path).to match(/foo/)
+    end
+  end
+
+  it "provides a writeable file" do
+    Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+      file.write("stuff")
+      file.flush
+
+      expect(Puppet::FileSystem.read(file.path)).to eq("stuff")
+    end
+  end
+
+  it "returns the value of the block" do
+    the_value = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+      "my value"
+    end
+
+    expect(the_value).to eq("my value")
+  end
+
+  it "unlinks the temporary file" do
+    filename = Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+      file.path
+    end
+
+    expect(Puppet::FileSystem.exist?(filename)).to be_false
+  end
+
+  it "unlinks the temporary file even if the block raises an error" do
+    filename = nil
+
+    begin
+      Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
+        filename = file.path
+        raise "error!"
+      end
+    rescue
+    end
+
+    expect(Puppet::FileSystem.exist?(filename)).to be_false
+  end
+
+
+  context "Ruby 1.9.3 Tempfile tests" do
+    # the remaining tests in this file are ported directly from the ruby 1.9.3 source,
+    # since most of this file was ported from there
+    # see: https://github.com/ruby/ruby/blob/v1_9_3_547/test/test_tempfile.rb
+
+    def tempfile(*args, &block)
+      t = Puppet::FileSystem::Uniquefile.new(*args, &block)
+      @tempfile = (t unless block)
+    end
+
+    after(:each) do
+      if @tempfile
+        @tempfile.close!
+      end
+    end
+
+    it "creates tempfiles" do
+      t = tempfile("foo")
+      path = t.path
+      t.write("hello world")
+      t.close
+      expect(File.read(path)).to eq("hello world")
+    end
+
+    it "saves in tmpdir by default" do
+      t = tempfile("foo")
+      expect(Dir.tmpdir).to eq(File.dirname(t.path))
+    end
+
+    it "saves in given directory" do
+      subdir = File.join(Dir.tmpdir, "tempfile-test-#{rand}")
+      Dir.mkdir(subdir)
+      begin
+        tempfile = Tempfile.new("foo", subdir)
+        tempfile.close
+        begin
+          expect(subdir).to eq(File.dirname(tempfile.path))
+        ensure
+          tempfile.unlink
+        end
+      ensure
+        Dir.rmdir(subdir)
+      end
+    end
+
+    it "supports basename" do
+      t = tempfile("foo")
+      expect(File.basename(t.path)).to match(/^foo/)
+    end
+
+    it "supports basename with suffix" do
+      t = tempfile(["foo", ".txt"])
+      expect(File.basename(t.path)).to match(/^foo/)
+      expect(File.basename(t.path)).to match(/\.txt$/)
+    end
+
+    it "supports unlink" do
+      t = tempfile("foo")
+      path = t.path
+      t.close
+      expect(File.exist?(path)).to eq(true)
+      t.unlink
+      expect(File.exist?(path)).to eq(false)
+      expect(t.path).to eq(nil)
+    end
+
+    it "supports closing" do
+      t = tempfile("foo")
+      expect(t.closed?).to eq(false)
+      t.close
+      expect(t.closed?).to eq(true)
+    end
+
+    it "supports closing and unlinking via boolean argument" do
+      t = tempfile("foo")
+      path = t.path
+      t.close(true)
+      expect(t.closed?).to eq(true)
+      expect(t.path).to eq(nil)
+      expect(File.exist?(path)).to eq(false)
+    end
+
+    context "on unix platforms", :unless => Puppet.features.microsoft_windows? do
+      it "close doesn't unlink if already unlinked" do
+        t = tempfile("foo")
+        path = t.path
+        t.unlink
+        File.open(path, "w").close
+        begin
+          t.close(true)
+          expect(File.exist?(path)).to eq(true)
+        ensure
+          File.unlink(path) rescue nil
+        end
+      end
+    end
+
+    it "supports close!" do
+      t = tempfile("foo")
+      path = t.path
+      t.close!
+      expect(t.closed?).to eq(true)
+      expect(t.path).to eq(nil)
+      expect(File.exist?(path)).to eq(false)
+    end
+
+    context "on unix platforms", :unless => Puppet.features.microsoft_windows? do
+      it "close! doesn't unlink if already unlinked" do
+        t = tempfile("foo")
+        path = t.path
+        t.unlink
+        File.open(path, "w").close
+        begin
+          t.close!
+          expect(File.exist?(path)).to eq(true)
+        ensure
+          File.unlink(path) rescue nil
+        end
+      end
+    end
+
+    it "close does not make path nil" do
+      t = tempfile("foo")
+      t.close
+      expect(t.path.nil?).to eq(false)
+    end
+
+    it "close flushes buffer" do
+      t = tempfile("foo")
+      t.write("hello")
+      t.close
+      expect(File.size(t.path)).to eq(5)
+    end
+  end
+end

data/spec/unit/forge/errors_spec.rb

@@ -47,15 +47,14 @@ Could not connect to http://fake.com:1111
       let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module') }
 
       it 'should return a valid single line error' do
-        exception.message.should == 'Could not execute operation for \'user/module\'. Detail: 404 not found.'
+        exception.message.should == 'Request to Puppet Forge failed. Detail: 404 not found.'
       end
 
       it 'should return a valid multiline error' do
         exception.multiline.should == <<-eos.chomp
-Could not execute operation for 'user/module'
+Request to Puppet Forge failed.
   The server being queried was http://fake.com:1111
   The HTTP response we received was '404 not found'
-    Check the author and module names are correct.
         eos
       end
     end
@@ -64,16 +63,15 @@ Could not execute operation for 'user/module'
       let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module', :message => 'no such module') }
 
       it 'should return a valid single line error' do
-        exception.message.should == 'Could not execute operation for \'user/module\'. Detail: no such module / 404 not found.'
+        exception.message.should == 'Request to Puppet Forge failed. Detail: no such module / 404 not found.'
       end
 
       it 'should return a valid multiline error' do
         exception.multiline.should == <<-eos.chomp
-Could not execute operation for 'user/module'
+Request to Puppet Forge failed.
   The server being queried was http://fake.com:1111
   The HTTP response we received was '404 not found'
   The message we received said 'no such module'
-    Check the author and module names are correct.
         eos
       end
     end