puppet 0.25.5 → 2.6.0

data/spec/unit/type/augeas_spec.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+augeas = Puppet::Type.type(:augeas)
+
+describe augeas do
+  describe "when augeas is present" do
+    confine "Augeas is unavailable" => Puppet.features.augeas?
+
+    it "should have a default provider inheriting from Puppet::Provider" do
+      augeas.defaultprovider.ancestors.should be_include(Puppet::Provider)
+    end
+
+    it "should have a valid provider" do
+      augeas.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
+    end
+  end
+
+  describe "basic structure" do
+    it "should be able to create a instance" do
+      provider_class = Puppet::Type::Augeas.provider(Puppet::Type::Augeas.providers[0])
+      Puppet::Type::Augeas.expects(:defaultprovider).returns provider_class
+      augeas.new(:name => "bar").should_not be_nil
+    end
+
+    it "should have an parse_commands feature" do
+      augeas.provider_feature(:parse_commands).should_not be_nil
+    end
+
+    it "should have an need_to_run? feature" do
+      augeas.provider_feature(:need_to_run?).should_not be_nil
+    end
+
+    it "should have an execute_changes feature" do
+      augeas.provider_feature(:execute_changes).should_not be_nil
+    end
+
+    properties = [:returns]
+    params = [:name, :context, :onlyif, :changes, :root, :load_path, :type_check]
+
+    properties.each do |property|
+      it "should have a #{property} property" do
+        augeas.attrclass(property).ancestors.should be_include(Puppet::Property)
+      end
+
+      it "should have documentation for its #{property} property" do
+        augeas.attrclass(property).doc.should be_instance_of(String)
+      end
+    end
+
+    params.each do |param|
+      it "should have a #{param} parameter" do
+        augeas.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+      end
+
+      it "should have documentation for its #{param} parameter" do
+        augeas.attrclass(param).doc.should be_instance_of(String)
+      end
+    end
+  end
+
+  describe "default values" do
+    before do
+      provider_class = augeas.provider(augeas.providers[0])
+      augeas.expects(:defaultprovider).returns provider_class
+    end
+
+    it "should be blank for context" do
+      augeas.new(:name => :context)[:context].should == ""
+    end
+
+    it "should be blank for onlyif" do
+      augeas.new(:name => :onlyif)[:onlyif].should == ""
+    end
+
+    it "should be blank for load_path" do
+      augeas.new(:name => :load_path)[:load_path].should == ""
+    end
+
+    it "should be / for root" do
+      augeas.new(:name => :root)[:root].should == "/"
+    end
+
+    it "should be false for type_check" do
+      augeas.new(:name => :type_check)[:type_check].should == :false
+    end
+  end
+
+  describe "provider interaction" do
+
+    it "should return 0 if it does not need to run" do
+      provider = stub("provider", :need_to_run? => false)
+      resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+      changes = augeas.attrclass(:returns).new(:resource => resource)
+      changes.retrieve.should == 0
+    end
+
+    it "should return :need_to_run if it needs to run" do
+      provider = stub("provider", :need_to_run? => true)
+      resource = stub('resource', :resource => nil, :provider => provider, :line => nil, :file => nil)
+      changes = augeas.attrclass(:returns).new(:resource => resource)
+      changes.retrieve.should == :need_to_run
+    end
+  end
+
+  describe "loading specific files" do
+    it "should require lens when incl is used" do
+      lambda { augeas.new(:name => :no_lens, :incl => "/etc/hosts")}.should raise_error(Puppet::Error)
+    end
+
+    it "should require incl when lens is used" do
+      lambda { augeas.new(:name => :no_incl, :lens => "Hosts.lns") }.should raise_error(Puppet::Error)
+    end
+
+    it "should set the context when a specific file is used" do
+      fake_provider = stub_everything "fake_provider"
+      augeas.stubs(:defaultprovider).returns fake_provider
+      augeas.new(:name => :no_incl, :lens => "Hosts.lns", :incl => "/etc/hosts")[:context].should == "/files/etc/hosts"
+    end
+  end
+end

data/spec/unit/type/component_spec.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+component = Puppet::Type.type(:component)
+
+describe component do
+  it "should have a :name attribute" do
+    component.attrclass(:name).should_not be_nil
+  end
+
+  it "should use Class as its type when a normal string is provided as the title" do
+    component.new(:name => "bar").ref.should == "Class[Bar]"
+  end
+
+  it "should always produce a resource reference string as its title" do
+    component.new(:name => "bar").title.should == "Class[Bar]"
+  end
+
+  it "should have a reference string equivalent to its title" do
+    comp = component.new(:name => "Foo[bar]")
+    comp.title.should == comp.ref
+  end
+
+  it "should alias itself to its reference if it has a catalog and the catalog does not already have a resource with the same reference" do
+    catalog = mock 'catalog'
+    catalog.expects(:resource).with("Foo[bar]").returns nil
+
+    catalog.expects(:alias).with { |resource, name| resource.is_a?(component) and name == "Foo[bar]" }
+
+    component.new(:name => "Foo[bar]", :catalog => catalog)
+  end
+
+  it "should not fail when provided an invalid value" do
+    comp = component.new(:name => "Foo[bar]")
+    lambda { comp[:yayness] = "ey" }.should_not raise_error
+  end
+
+  it "should return previously provided invalid values" do
+    comp = component.new(:name => "Foo[bar]")
+    comp[:yayness] = "eh"
+    comp[:yayness].should == "eh"
+  end
+
+  it "should correctly support metaparameters" do
+    comp = component.new(:name => "Foo[bar]", :require => "Foo[bar]")
+    comp.parameter(:require).should be_instance_of(component.attrclass(:require))
+  end
+
+  describe "when building up the path" do
+    it "should produce the class name if the component models a class" do
+      component.new(:name => "Class[foo]").pathbuilder.must == ["Foo"]
+    end
+
+    it "should produce an empty string if the component models the 'main' class" do
+      component.new(:name => "Class[main]").pathbuilder.must == [""]
+    end
+
+    it "should produce a resource reference if the component does not model a class" do
+      component.new(:name => "Foo[bar]").pathbuilder.must == ["Foo[bar]"]
+    end
+  end
+end

data/spec/unit/type/computer_spec.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+computer = Puppet::Type.type(:computer)
+
+describe Puppet::Type.type(:computer), " when checking computer objects" do
+  before do
+    provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
+    Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
+
+          @resource = Puppet::Type::Computer.new(
+                
+            :name => "puppetcomputertest",
+            :en_address => "aa:bb:cc:dd:ee:ff",
+        
+            :ip_address => "1.2.3.4")
+    @properties = {}
+    @ensure = Puppet::Type::Computer.attrclass(:ensure).new(:resource => @resource)
+  end
+
+  it "should be able to create a instance" do
+    provider_class = Puppet::Type::Computer.provider(Puppet::Type::Computer.providers[0])
+    Puppet::Type::Computer.expects(:defaultprovider).returns provider_class
+    computer.new(:name => "bar").should_not be_nil
+  end
+
+  properties = [:en_address, :ip_address]
+  params = [:name]
+
+  properties.each do |property|
+    it "should have a #{property} property" do
+      computer.attrclass(property).ancestors.should be_include(Puppet::Property)
+    end
+
+    it "should have documentation for its #{property} property" do
+      computer.attrclass(property).doc.should be_instance_of(String)
+    end
+
+    it "should accept :absent as a value" do
+      prop = computer.attrclass(property).new(:resource => @resource)
+      prop.should = :absent
+      prop.should.must == :absent
+    end
+  end
+
+  params.each do |param|
+    it "should have a #{param} parameter" do
+      computer.attrclass(param).ancestors.should be_include(Puppet::Parameter)
+    end
+
+    it "should have documentation for its #{param} parameter" do
+      computer.attrclass(param).doc.should be_instance_of(String)
+    end
+  end
+
+  describe "default values" do
+    before do
+      provider_class = computer.provider(computer.providers[0])
+      computer.expects(:defaultprovider).returns provider_class
+    end
+
+    it "should be nil for en_address" do
+      computer.new(:name => :en_address)[:en_address].should == nil
+    end
+
+    it "should be nil for ip_address" do
+      computer.new(:name => :ip_address)[:ip_address].should == nil
+    end
+  end
+
+  describe "when managing the ensure property" do
+    it "should support a :present value" do
+      lambda { @ensure.should = :present }.should_not raise_error
+    end
+
+    it "should support an :absent value" do
+      lambda { @ensure.should = :absent }.should_not raise_error
+    end
+  end
+end

data/spec/unit/type/cron_spec.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+describe Puppet::Type.type(:cron) do
+  before do
+    @cron = Puppet::Type.type(:cron).new( :name => "foo" )
+  end
+
+  it "it should accept an :environment that looks like a path" do
+    lambda do
+      @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
+    end.should_not raise_error
+  end
+
+  it "should not accept environment variables that do not contain '='" do
+    lambda do
+      @cron[:environment] = "INVALID"
+    end.should raise_error(Puppet::Error)
+  end
+
+  it "should accept empty environment variables that do not contain '='" do
+    lambda do
+      @cron[:environment] = "MAILTO="
+    end.should_not raise_error(Puppet::Error)
+  end
+
+  it "should accept 'absent'" do
+    lambda do
+      @cron[:environment] = 'absent'
+    end.should_not raise_error(Puppet::Error)
+  end
+end

data/spec/unit/type/exec_spec.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Type.type(:exec) do
+
+  def create_resource(command, output, exitstatus, returns = 0)
+    @user_name = 'some_user_name'
+    @group_name = 'some_group_name'
+    Puppet.features.stubs(:root?).returns(true)
+    @execer = Puppet::Type.type(:exec).new(:name => command, :path => @example_path, :user => @user_name, :group => @group_name, :returns => returns)
+
+    status = stub "process"
+    status.stubs(:exitstatus).returns(exitstatus)
+
+    Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], @user_name, @group_name).returns([output, status])
+  end
+
+  def create_logging_resource(command, output, exitstatus, logoutput, loglevel, returns = 0)
+    create_resource(command, output, exitstatus, returns)
+    @execer[:logoutput] = logoutput
+    @execer[:loglevel] = loglevel
+  end
+
+  def expect_output(output, loglevel)
+    output.split(/\n/).each do |line|
+      @execer.property(:returns).expects(loglevel).with(line)
+    end
+  end
+
+  before do
+    @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
+    @command = Puppet.features.posix? ? '/bin/true whatever' : '"C:/Program Files/something.exe" whatever'
+    File.stubs(:exists?).returns false
+    File.stubs(:exists?).with(@executable).returns true
+    @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
+    File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
+    File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
+  end
+
+  it "should return :executed_command as its event" do
+    resource = Puppet::Type.type(:exec).new :command => @command
+    resource.parameter(:returns).event.name.should == :executed_command
+  end
+
+  describe "when execing" do
+
+    it "should use the 'run_and_capture' method to exec" do
+      command = "true"
+      create_resource(command, "", 0)
+
+      @execer.refresh.should == :executed_command
+    end
+
+    it "should report a failure" do
+      command = "false"
+      create_resource(command, "", 1)
+
+      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "should not report a failure if the exit status is specified in a returns array" do
+      command = "false"
+      create_resource(command, "", 1, [0,1])
+      proc { @execer.refresh }.should_not raise_error(Puppet::Error)
+    end
+
+    it "should report a failure if the exit status is not specified in a returns array" do
+      command = "false"
+      create_resource(command, "", 1, [0,100])
+      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "should log the output on success" do
+      #Puppet::Util::Log.newdestination :console
+      command = "false"
+      output = "output1\noutput2\n"
+      create_logging_resource(command, output, 0, true, :err)
+      expect_output(output, :err)
+      @execer.refresh
+    end
+
+    it "should log the output on failure" do
+      #Puppet::Util::Log.newdestination :console
+      command = "false"
+      output = "output1\noutput2\n"
+      create_logging_resource(command, output, 1, true, :err)
+      expect_output(output, :err)
+
+      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+  end
+
+  describe "when logoutput=>on_failure is set" do
+
+    it "should log the output on failure" do
+      #Puppet::Util::Log.newdestination :console
+      command = "false"
+      output = "output1\noutput2\n"
+      create_logging_resource(command, output, 1, :on_failure, :err)
+      expect_output(output, :err)
+
+      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "should log the output on failure when returns is specified as an array" do
+      #Puppet::Util::Log.newdestination :console
+      command = "false"
+      output = "output1\noutput2\n"
+      create_logging_resource(command, output, 1, :on_failure, :err, [0, 100])
+      expect_output(output, :err)
+
+      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    end
+
+    it "shouldn't log the output on success" do
+      #Puppet::Util::Log.newdestination :console
+      command = "true"
+      output = "output1\noutput2\n"
+      create_logging_resource(command, output, 0, :on_failure, :err)
+      @execer.property(:returns).expects(:err).never
+      @execer.refresh
+    end
+  end
+
+  it "shouldn't log the output on success when non-zero exit status is in a returns array" do
+    #Puppet::Util::Log.newdestination :console
+    command = "true"
+    output = "output1\noutput2\n"
+    create_logging_resource(command, output, 100, :on_failure, :err, [1,100])
+    @execer.property(:returns).expects(:err).never
+    @execer.refresh
+  end
+
+  describe " when multiple tries are set," do
+
+    it "should repeat the command attempt 'tries' times on failure and produce an error" do
+      Puppet.features.stubs(:root?).returns(true)
+      command = "false"
+      user = "user"
+      group = "group"
+      tries = 5
+      retry_exec = Puppet::Type.type(:exec).new(:name => command, :path => %w{/usr/bin /bin}, :user => user, :group => group, :returns => 0, :tries => tries, :try_sleep => 0)
+      status = stub "process"
+      status.stubs(:exitstatus).returns(1)
+      Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], user, group).times(tries).returns(["", status])
+      proc { retry_exec.refresh }.should raise_error(Puppet::Error)
+    end
+  end
+
+  it "should be able to autorequire files mentioned in the command" do
+    catalog = Puppet::Resource::Catalog.new
+    catalog.add_resource Puppet::Type.type(:file).new(:name => @executable)
+    @execer = Puppet::Type.type(:exec).new(:name => @command)
+    catalog.add_resource @execer
+
+    rels = @execer.autorequire
+    rels[0].should be_instance_of(Puppet::Relationship)
+    rels[0].target.should equal(@execer)
+  end
+end