puppet 2.6.7 → 2.6.8

data/spec/unit/indirector/exec_spec.rb

@@ -47,10 +47,9 @@ describe Puppet::Indirector::Exec do
     @searcher.find(@request).should be_nil
   end
 
-  it "should return nil and log an error if there's an execution failure" do
+  it "should raise an exception if there's an execution failure" do
     @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
 
-    Puppet.expects(:err)
-    @searcher.find(@request).should be_nil
+    lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end

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

@@ -1,7 +1,10 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
-require 'sqlite3' rescue nil
+begin
+  require 'sqlite3'
+rescue LoadError
+end
 require 'tempfile'
 require 'puppet/rails'
 
@@ -29,6 +32,7 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
 
   after :each do
     Puppet::Rails.teardown
+    ActiveRecord::Base.remove_connection
   end
 
   describe "#save" do

data/spec/unit/indirector/report/yaml_spec.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/transaction/report'
+require 'puppet/indirector/report/yaml'
+
+describe Puppet::Transaction::Report::Yaml do
+  it "should be a subclass of the Yaml terminus" do
+    Puppet::Transaction::Report::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+  end
+
+  it "should have documentation" do
+    Puppet::Transaction::Report::Yaml.doc.should_not be_nil
+  end
+
+  it "should be registered with the report indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:report)
+    Puppet::Transaction::Report::Yaml.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :yaml" do
+    Puppet::Transaction::Report::Yaml.name.should == :yaml
+  end
+
+  it "should inconditionnally save/load from the --lastrunreport setting" do
+    indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
+    Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(indirection)
+    store_class = Class.new(Puppet::Transaction::Report::Yaml) do
+      def self.to_s
+        "MyYaml::MyType"
+      end
+    end
+    store = store_class.new
+
+    store.path(:me).should == Puppet[:lastrunreport]
+  end
+end

data/spec/unit/node/environment_spec.rb

@@ -85,28 +85,29 @@ describe Puppet::Node::Environment do
       @env.known_resource_types.should equal(@collection)
     end
 
-    it "should give to all threads the same collection if it didn't change" do
-      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
-      @env.known_resource_types
+    it "should give to all threads using the same environment the same collection if the collection isn't stale" do
+      original_thread_type_collection = Puppet::Resource::TypeCollection.new(@env)
+      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns original_thread_type_collection
+      @env.known_resource_types.should equal(original_thread_type_collection)
+
+      original_thread_type_collection.expects(:require_reparse?).returns(false)
+      Puppet::Resource::TypeCollection.stubs(:new).with(@env).returns @collection
 
       t = Thread.new {
-        @env.known_resource_types.should equal(@collection)
+        @env.known_resource_types.should equal(original_thread_type_collection)
       }
       t.join
     end
 
-    it "should give to new threads a new collection if it isn't stale" do
-      Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
-      @env.known_resource_types.expects(:stale?).returns(true)
-
-      Puppet::Resource::TypeCollection.expects(:new).returns @collection
+    it "should generate a new TypeCollection if the current one requires reparsing" do
+      old_type_collection = @env.known_resource_types
+      old_type_collection.stubs(:require_reparse?).returns true
+      Thread.current[:known_resource_types] = nil
+      new_type_collection = @env.known_resource_types
 
-      t = Thread.new {
-        @env.known_resource_types.should equal(@collection)
-      }
-      t.join
+      new_type_collection.should be_a Puppet::Resource::TypeCollection
+      new_type_collection.should_not equal(old_type_collection)
     end
-
   end
 
   [:modulepath, :manifestdir].each do |setting|

data/spec/unit/parameter/path_spec.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+require 'puppet/parameter/path'
+
+[false, true].each do |arrays|
+  describe "Puppet::Parameter::Path with arrays #{arrays}" do
+    it_should_behave_like "all path parameters", :path, :array => arrays do
+      # The new type allows us a test that is guaranteed to go direct to our
+      # validation code, without passing through any "real type" overrides or
+      # whatever on the way.
+      Puppet::newtype(:test_puppet_parameter_path) do
+        newparam(:path, :parent => Puppet::Parameter::Path, :arrays => arrays) do
+          isnamevar
+          accept_arrays arrays
+        end
+      end
+
+      def instance(path)
+        Puppet::Type.type(:test_puppet_parameter_path).new(:path => path)
+      end
+    end
+  end
+end

data/spec/unit/parser/compiler_spec.rb

@@ -581,12 +581,11 @@ describe Puppet::Parser::Compiler do
       @scope.expects(:find_hostclass).with("notfound").returns(nil)
       @compiler.evaluate_classes(%w{notfound}, @scope)
     end
-    # I wish it would fail
     it "should log when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
       @compiler.topscope.stubs(:find_hostclass).with('foo').returns(nil)
-      Puppet.expects(:info).with('Could not find class foo for testnode')
+      Puppet.expects(:warning).with('Could not find class foo for testnode')
       @compiler.compile
     end
   end

data/spec/unit/parser/lexer_spec.rb

@@ -679,3 +679,15 @@ describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
     end
   end
 end
+
+describe "when trying to lex an non-existent file" do
+  include PuppetSpec::Files
+
+  it "should return an empty list of tokens" do
+    lexer = Puppet::Parser::Lexer.new
+    lexer.file = nofile = tmpfile('lexer')
+    File.exists?(nofile).should == false
+
+    lexer.fullscan.should == [[false,false]]
+  end
+end

data/spec/unit/provider/exec/posix_spec.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:posix)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  ["posix", "microsoft_windows"].each do |feature|
+    describe "when in #{feature} environment" do
+      before :each do
+        if feature == "microsoft_windows"
+          Puppet.features.stubs(:microsoft_windows?).returns(true)
+          Puppet.features.stubs(:posix?).returns(false)
+        else
+          Puppet.features.stubs(:posix?).returns(true)
+          Puppet.features.stubs(:microsoft_windows?).returns(false)
+        end
+      end
+
+      describe "#validatecmd" do
+        it "should fail if no path is specified and the command is not fully qualified" do
+          lambda { @provider.validatecmd("foo") }.should raise_error(
+            Puppet::Error,
+            "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
+          )
+        end
+
+        it "should pass if a path is given" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("../foo")
+        end
+
+        it "should pass if command is fully qualifed" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("/bin/blah/foo")
+        end
+      end
+
+      describe "#run" do
+        it "should fail if no path is specified and command does not exist" do
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't in the path" do
+          @provider.resource[:path] = ['/bogus/bin']
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "'foo' is not executable")
+        end
+
+        it "should not be able to execute shell builtins" do
+          @provider.resource[:path] = ['/bin']
+          lambda { @provider.run("cd ..") }.should raise_error(ArgumentError, "Could not find command 'cd'")
+        end
+
+        it "should execute the command if the command given includes arguments or subcommands" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo bar --sillyarg=true --blah']) && (arguments.is_a? Hash) }
+          @provider.run("foo bar --sillyarg=true --blah")
+        end
+
+        it "should fail if quoted command doesn't exist" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          lambda { @provider.run('"foo bar --sillyarg=true --blah"') }.should raise_error(ArgumentError, "Could not find command 'foo bar --sillyarg=true --blah'")
+        end
+
+        it "should execute the command if it finds it in the path and is executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+
+          @provider.run("foo")
+        end
+
+        if feature == "microsoft_windows"
+          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
+            it "should check file extension #{extension} when it can't find the executable" do
+              @provider.resource[:path] = ['/bogus/bin']
+              File.stubs(:exists?).returns(false)
+              File.stubs(:exists?).with("/bogus/bin/foo#{extension}").returns(true)
+              File.stubs(:executable?).with("foo").returns(true)
+              Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+
+              @provider.run("foo")
+            end
+          end
+        end
+
+        it "should warn if you're overriding something in environment" do
+          @provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+          @provider.run("foo")
+          @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
+        end
+      end
+    end
+  end
+end

data/spec/unit/provider/exec/shell_spec.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:shell)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  describe "#run" do
+    it "should be able to run builtin shell commands" do
+      output, status = @provider.run("if [ 1 = 1 ]; then echo 'blah'; fi")
+      status.exitstatus.should == 0
+      output.should == "blah\n"
+    end
+
+    it "should be able to run commands with single quotes in them" do
+      output, status = @provider.run("echo 'foo  bar'")
+      status.exitstatus.should == 0
+      output.should == "foo  bar\n"
+    end
+
+    it "should be able to run commands with double quotes in them" do
+      output, status = @provider.run('echo "foo  bar"')
+      status.exitstatus.should == 0
+      output.should == "foo  bar\n"
+    end
+
+    it "should be able to run multiple commands separated by a semicolon" do
+      output, status = @provider.run("echo 'foo' ; echo 'bar'")
+      status.exitstatus.should == 0
+      output.should == "foo\nbar\n"
+    end
+
+    it "should be able to read values from the environment parameter" do
+      @resource[:environment] = "FOO=bar"
+      output, status = @provider.run("echo $FOO")
+      status.exitstatus.should == 0
+      output.should == "bar\n"
+    end
+  end
+
+  describe "#validatecmd" do
+    it "should always return true because builtins don't need path or to be fully qualified" do
+      @provider.validatecmd('whateverdoesntmatter').should == true
+    end
+  end
+end

data/spec/unit/provider/group/groupadd_spec.rb

@@ -10,10 +10,10 @@ describe provider_class do
     @provider = provider_class.new(@resource)
   end
 
-  # #1360
   it "should add -o when allowdupe is enabled and the group is being created" do
     @resource.stubs(:should).returns "fakeval"
     @resource.stubs(:[]).returns "fakeval"
+    @resource.stubs(:system?).returns true
     @resource.expects(:allowdupe?).returns true
     @provider.expects(:execute).with { |args| args.include?("-o") }
 
@@ -28,4 +28,14 @@ describe provider_class do
 
     @provider.gid = 150
   end
+
+  it "should add -r when system is enabled and the group is being created" do
+    @resource.stubs(:should).returns "fakeval"
+    @resource.stubs(:[]).returns "fakeval"
+    @resource.expects(:system?).returns true
+    @resource.stubs(:allowdupe?).returns true
+    @provider.expects(:execute).with { |args| args.include?("-r") }
+
+    @provider.create
+  end
 end

data/spec/unit/provider/package/gem_spec.rb

@@ -42,8 +42,18 @@ describe provider_class do
       @provider.install
     end
 
+    it "should specify that documentation should not be included" do
+      @provider.expects(:execute).with { |args| args[3] == "--no-rdoc" }.returns ""
+      @provider.install
+    end
+
+    it "should specify that RI should not be included" do
+      @provider.expects(:execute).with { |args| args[4] == "--no-ri" }.returns ""
+      @provider.install
+    end
+
     it "should specify the package name" do
-      @provider.expects(:execute).with { |args| args[3] == "myresource" }.returns ""
+      @provider.expects(:execute).with { |args| args[5] == "myresource" }.returns ""
       @provider.install
     end
 

data/spec/unit/provider/package/macports_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:package).provider(:macports)
+
+describe provider_class do
+  let :resource_name do
+    "foo"
+  end
+
+  let :resource do
+    Puppet::Type.type(:package).new(:name => resource_name, :provider => :macports)
+  end
+
+  let :provider do
+    prov = resource.provider
+    prov.expects(:execute).never
+    prov
+  end
+
+  let :current_hash do
+    {:name => resource_name, :ensure => "1.2.3", :revision => "1", :provider => :macports}
+  end
+
+  describe "provider features" do
+    subject { provider }
+
+    it { should be_installable }
+    it { should be_uninstallable }
+    it { should be_upgradeable }
+    it { should be_versionable }
+  end
+
+  describe "when listing all instances" do
+    it "should call port -q installed" do
+      provider_class.expects(:port).with("-q", :installed).returns("")
+      provider_class.instances
+    end
+
+    it "should create instances from active ports" do
+      provider_class.expects(:port).returns("foo @1.234.5_2 (active)")
+      provider_class.instances.size.should == 1
+    end
+
+    it "should ignore ports that aren't activated" do
+      provider_class.expects(:port).returns("foo @1.234.5_2")
+      provider_class.instances.size.should == 0
+    end
+  end
+
+  describe "when installing" do
+   it "should not specify a version when ensure is set to latest" do
+     resource[:ensure] = :latest
+     provider.expects(:port).with { |flag, method, name, version|
+       version.should be_nil
+     }
+     provider.install
+   end
+
+   it "should not specify a version when ensure is set to present" do
+     resource[:ensure] = :present
+     provider.expects(:port).with { |flag, method, name, version|
+       version.should be_nil
+     }
+     provider.install
+   end
+
+   it "should specify a version when ensure is set to a version" do
+     resource[:ensure] = "1.2.3"
+     provider.expects(:port).with { |flag, method, name, version|
+       version.should be
+     }
+     provider.install
+   end
+  end
+
+  describe "when querying for the latest version" do
+    let :new_info_line do
+      "1.2.3 2"
+    end
+    let :infoargs do
+      ["-q", :info, "--line", "--version", "--revision",  resource_name]
+    end
+
+    it "should return nil when the package cannot be found" do
+      resource[:name] = resource_name
+      provider.expects(:port).returns("")
+      provider.latest.should == nil
+    end
+
+    it "should return the current version if the installed port has the same revision" do
+      current_hash[:revision] = "2"
+      provider.expects(:port).with(*infoargs).returns(new_info_line)
+      provider.expects(:query).returns(current_hash)
+      provider.latest.should == current_hash[:ensure]
+    end
+
+    it "should return the new version_revision if the installed port has a lower revision" do
+      current_hash[:revision] = "1"
+      provider.expects(:port).with(*infoargs).returns(new_info_line)
+      provider.expects(:query).returns(current_hash)
+      provider.latest.should == "1.2.3_2"
+    end
+  end
+
+  describe "when updating a port" do
+    it "should execute port upgrade if the port is installed" do
+      resource[:name] = resource_name
+      resource[:ensure] = :present
+      provider.expects(:query).returns(current_hash)
+      provider.expects(:port).with("-q", :upgrade, resource_name)
+      provider.update
+    end
+
+    it "should execute port install if the port is not installed" do
+      resource[:name] = resource_name
+      resource[:ensure] = :present
+      provider.expects(:query).returns("")
+      provider.expects(:port).with("-q", :install, resource_name)
+      provider.update
+    end
+  end
+end