puppet 0.25.5 → 2.6.0

data/test/other/provider.rb

@@ -7,110 +7,95 @@ require 'puppet/provider'
 require 'puppettest'
 
 class TestImpl < Test::Unit::TestCase
-    include PuppetTest
-
-    def setup
-        super
-        @type = newtype(@method_name.to_s + "type")
-
-        # But create a new provider for every method.
-        @provider = newprovider(@method_name.to_s + "provider")
+  include PuppetTest
+
+  def setup
+    super
+    @type = newtype(@method_name.to_s + "type")
+
+    # But create a new provider for every method.
+    @provider = newprovider(@method_name.to_s + "provider")
+  end
+
+  def newtype(name)
+    # First create a fake type
+    return Puppet::Type.newtype(name) {
+      newparam(:name) { isnamevar }
+    }
+  end
+
+  def newprovider(name, type = nil)
+    type ||= @type
+    provider = nil
+    assert_nothing_raised("Could not create provider") do
+      provider = type.provide(name) {}
     end
+    provider
+  end
 
-    def newtype(name)
-        # First create a fake type
-        return Puppet::Type.newtype(name) {
-            newparam(:name) { isnamevar }
-        }
-    end
+  def test_provider_default
+    nondef = nil
+    assert_nothing_raised {
+      nondef = newprovider(:nondefault)
+    }
 
-    def newprovider(name, type = nil)
-        type ||= @type
-        provider = nil
-        assert_nothing_raised("Could not create provider") do
-            provider = type.provide(name) {}
-        end
-        return provider
+    assert_nothing_raised do
+      @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
     end
 
-    # Just a quick run-through to see if the basics work
-    def test_newprovider
-        assert_nothing_raised do
-            @provider.confine :operatingsystem => Facter["operatingsystem"].value
-            @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
-        end
+    assert_equal(@provider.name, @type.defaultprovider.name, "Did not get right provider")
 
-        assert(@provider.suitable?, "Implementation was not considered suitable")
-        assert(@provider.default?, "Implementation was not considered a default")
+    @type.suitableprovider
+  end
 
-        assert_equal(@provider, @type.defaultprovider,
-                     "Did not correctly find default provider")
+  def test_subclassconfines
+    parent = newprovider("parentprovider")
 
-    end
+    # Now make a bad confine on the parent
+    parent.confine :exists => "/this/file/definitely/does/not/exist"
 
-    def test_provider_default
-        nondef = nil
-        assert_nothing_raised {
-            nondef = newprovider(:nondefault)
-        }
+    child = nil
+    assert_nothing_raised {
+      child = @type.provide("child", :parent => parent.name) {}
+    }
 
-        assert_nothing_raised do
-            @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
-        end
+    assert(child.suitable?, "Parent ruled out child")
+  end
 
-        assert_equal(@provider.name, @type.defaultprovider.name, "Did not get right provider")
+  def test_commands
+    parent = newprovider("parentprovider")
 
-        @type.suitableprovider
-    end
+    child = nil
+    assert_nothing_raised {
+      child = @type.provide("child", :parent => parent.name) {}
+    }
 
-    def test_subclassconfines
-        parent = newprovider("parentprovider")
+    assert_nothing_raised {
+      child.commands :which => "which"
+    }
 
-        # Now make a bad confine on the parent
-        parent.confine :exists => "/this/file/definitely/does/not/exist"
+    assert(child.command(:which), "Did not find 'which' command")
 
-        child = nil
-        assert_nothing_raised {
-            child = @type.provide("child", :parent => parent.name) {}
-        }
+    assert(child.command(:which) =~ /^\//,
+        "Command did not become fully qualified")
+    assert(FileTest.exists?(child.command(:which)),
+                "Did not find actual 'which' binary")
 
-        assert(child.suitable?, "Parent ruled out child")
+    assert_raise(Puppet::DevError) do
+      child.command(:nosuchcommand)
     end
 
-    def test_commands
-        parent = newprovider("parentprovider")
-
-        child = nil
-        assert_nothing_raised {
-            child = @type.provide("child", :parent => parent.name) {}
-        }
+    # Now create a parent command
+    assert_nothing_raised {
+      parent.commands :sh => Puppet::Util.binary('sh')
+    }
 
-        assert_nothing_raised {
-            child.commands :which => "which"
-        }
+    assert(parent.command(:sh), "Did not find 'sh' command")
 
-        assert(child.command(:which), "Did not find 'which' command")
+    assert(child.command(:sh), "Did not find parent's 'sh' command")
 
-        assert(child.command(:which) =~ /^\//,
-                "Command did not become fully qualified")
-        assert(FileTest.exists?(child.command(:which)),
-                                "Did not find actual 'which' binary")
-
-        assert_raise(Puppet::DevError) do
-            child.command(:nosuchcommand)
-        end
-
-        # Now create a parent command
-        assert_nothing_raised {
-            parent.commands :sh => Puppet::Util.binary('sh')
-        }
-
-        assert(parent.command(:sh), "Did not find 'sh' command")
-
-        assert(child.command(:sh), "Did not find parent's 'sh' command")
-
-        assert(FileTest.exists?(child.command(:sh)),
-                                "Somehow broke path to sh")
-    end
+    assert(FileTest.exists?(child.command(:sh)),
+                "Somehow broke path to sh")
+  end
 end
 

data/test/other/puppet.rb

@@ -7,95 +7,80 @@ require 'puppettest'
 
 # Test the different features of the main puppet module
 class TestPuppetModule < Test::Unit::TestCase
-    include PuppetTest
-    include SignalObserver
-
-    def mkfakeclient
-        Class.new(Puppet::Network::Client) do
-            def initialize
-            end
-
-            def runnow
-                Puppet.info "fake client has run"
-            end
-        end
+  include PuppetTest
+  include SignalObserver
+
+  def mkfakeclient
+    Class.new(Puppet::Network::Client) do
+      def initialize
+      end
+
+      def runnow
+        Puppet.info "fake client has run"
+      end
     end
+  end
 
-    def mktestclass
-        Class.new do
-            def initialize(file)
-                @file = file
-            end
+  def mktestclass
+    Class.new do
+      def initialize(file)
+        @file = file
+      end
 
-            def started?
-                FileTest.exists?(@file)
-            end
+      def started?
+        FileTest.exists?(@file)
+      end
 
-            def start
-                File.open(@file, "w") do |f| f.puts "" end
-            end
+      def start
+        File.open(@file, "w") do |f| f.puts "" end
+      end
 
-            def shutdown
-                File.unlink(@file)
-            end
-        end
+      def shutdown
+        File.unlink(@file)
+      end
     end
+  end
 
-    def test_path
-        oldpath = ENV["PATH"]
-        cleanup do
-            ENV["PATH"] = oldpath
-        end
-        newpath = oldpath + ":" + "/something/else"
-        assert_nothing_raised do
-            Puppet[:path] = newpath
-        end
-
-        assert_equal(newpath, ENV["PATH"])
+  def test_path
+    oldpath = ENV["PATH"]
+    cleanup do
+      ENV["PATH"] = oldpath
     end
-
-    def test_libdir
-        oldlibs = $:.dup
-        cleanup do
-            $:.each do |dir|
-                unless oldlibs.include?(dir)
-                    $:.delete(dir)
-                end
-            end
-        end
-        one = tempfile()
-        two = tempfile()
-        Dir.mkdir(one)
-        Dir.mkdir(two)
-
-        # Make sure setting the libdir gets the dir added to $:
-        assert_nothing_raised do
-            Puppet[:libdir] = one
-        end
-
-        assert($:.include?(one), "libdir was not added")
-
-        # Now change it, make sure it gets added and the old one gets
-        # removed
-        assert_nothing_raised do
-            Puppet[:libdir] = two
-        end
-
-        assert($:.include?(two), "libdir was not added")
-        assert(! $:.include?(one), "old libdir was not removed")
+    newpath = oldpath + ":/something/else"
+    assert_nothing_raised do
+      Puppet[:path] = newpath
     end
 
-    def test_name
-        # Make sure it defaults to $0 without the rb
-        should = $0.gsub(/.+#{File::SEPARATOR}/,'').sub(/\.rb$/, '')
+    assert_equal(newpath, ENV["PATH"])
+  end
 
-        assert_equal(should, Puppet[:name], "default name was not right")
+  def test_libdir
+    oldlibs = $LOAD_PATH.dup
+    cleanup do
+      $LOAD_PATH.each do |dir|
+        $LOAD_PATH.delete(dir) unless oldlibs.include?(dir)
+      end
+    end
+    one = tempfile
+    two = tempfile
+    Dir.mkdir(one)
+    Dir.mkdir(two)
+
+    # Make sure setting the libdir gets the dir added to $LOAD_PATH
+    assert_nothing_raised do
+      Puppet[:libdir] = one
+    end
 
-        assert_nothing_raised("Could not reset name") do
-            Puppet[:name] = "puppetca"
-        end
+    assert($LOAD_PATH.include?(one), "libdir was not added")
 
-        assert_equal("puppetca", Puppet[:name], "name reset did not take")
+    # Now change it, make sure it gets added and the old one gets
+    # removed
+    assert_nothing_raised do
+      Puppet[:libdir] = two
     end
+
+    assert($LOAD_PATH.include?(two), "libdir was not added")
+    assert(! $LOAD_PATH.include?(one), "old libdir was not removed")
+  end
 end
 

data/test/other/relationships.rb

@@ -6,85 +6,93 @@ require 'puppet'
 require 'puppettest'
 
 class TestRelationships < Test::Unit::TestCase
-    include PuppetTest
-    def setup
-        super
-        Puppet::Type.type(:exec)
-    end
+  include PuppetTest
+  def setup
+    super
+    Puppet::Type.type(:exec)
+  end
+
+  def newfile
+    assert_nothing_raised {
 
-    def newfile
-        assert_nothing_raised() {
             return Puppet::Type.type(:file).new(
-                :path => tempfile,
-                :check => [:mode, :owner, :group]
-            )
-        }
+                
+        :path => tempfile,
+        
+        :check => [:mode, :owner, :group]
+      )
+    }
+  end
+
+  def check_relationship(sources, targets, out, refresher)
+    if out
+      deps = sources.builddepends
+      sources = [sources]
+    else
+      deps = targets.builddepends
+      targets = [targets]
     end
+    assert_instance_of(Array, deps)
+    assert(! deps.empty?, "Did not receive any relationships")
 
-    def check_relationship(sources, targets, out, refresher)
-        if out
-            deps = sources.builddepends
-            sources = [sources]
-        else
-            deps = targets.builddepends
-            targets = [targets]
-        end
-        assert_instance_of(Array, deps)
-        assert(! deps.empty?, "Did not receive any relationships")
+    deps.each do |edge|
+      assert_instance_of(Puppet::Relationship, edge)
+    end
 
-        deps.each do |edge|
-            assert_instance_of(Puppet::Relationship, edge)
-        end
+    sources.each do |source|
+      targets.each do |target|
+        edge = deps.find { |e| e.source == source and e.target == target }
+        assert(edge, "Could not find edge for #{source.ref} => #{target.ref}")
 
-        sources.each do |source|
-            targets.each do |target|
-                edge = deps.find { |e| e.source == source and e.target == target }
-                assert(edge, "Could not find edge for %s => %s" %
-                    [source.ref, target.ref])
-
-                if refresher
-                    assert_equal(:ALL_EVENTS, edge.event)
-                    assert_equal(:refresh, edge.callback)
-                else
-                    assert_nil(edge.event)
-                    assert_nil(edge.callback, "Got a callback with no events")
-                end
-            end
+        if refresher
+          assert_equal(:ALL_EVENTS, edge.event)
+          assert_equal(:refresh, edge.callback)
+        else
+          assert_nil(edge.event)
+          assert_nil(edge.callback, "Got a callback with no events")
         end
+      end
     end
+  end
 
-    def test_autorequire
-        # We know that execs autorequire their cwd, so we'll use that
-        path = tempfile()
+  def test_autorequire
+    # We know that execs autorequire their cwd, so we'll use that
+    path = tempfile
 
-        file = Puppet::Type.type(:file).new(:title => "myfile", :path => path,
-            :ensure => :directory)
-        exec = Puppet::Type.newexec(:title => "myexec", :cwd => path,
-            :command => "/bin/echo")
 
-        catalog = mk_catalog(file, exec)
-        reqs = nil
-        assert_nothing_raised do
-            reqs = exec.autorequire
-        end
-        assert_instance_of(Puppet::Relationship, reqs[0], "Did not return a relationship edge")
-        assert_equal(file, reqs[0].source, "Did not set the autorequire source correctly")
-        assert_equal(exec, reqs[0].target, "Did not set the autorequire target correctly")
-
-        # Now make sure that these relationships are added to the
-        # relationship graph
-        catalog.apply do |trans|
-            assert(catalog.relationship_graph.edge?(file, exec), "autorequire edge was not created")
-        end
+          file = Puppet::Type.type(:file).new(
+        :title => "myfile", :path => path,
+        
+      :ensure => :directory)
+
+          exec = Puppet::Type.newexec(
+        :title => "myexec", :cwd => path,
+        
+      :command => "/bin/echo")
+
+    catalog = mk_catalog(file, exec)
+    reqs = nil
+    assert_nothing_raised do
+      reqs = exec.autorequire
     end
+    assert_instance_of(Puppet::Relationship, reqs[0], "Did not return a relationship edge")
+    assert_equal(file, reqs[0].source, "Did not set the autorequire source correctly")
+    assert_equal(exec, reqs[0].target, "Did not set the autorequire target correctly")
 
-    # Testing #411.  It was a problem with builddepends.
-    def test_missing_deps
-        file = Puppet::Type.type(:file).new :path => tempfile, :require => Puppet::Resource::Reference.new("file", "/no/such/file")
+    # Now make sure that these relationships are added to the
+    # relationship graph
+    catalog.apply do |trans|
+      assert(catalog.relationship_graph.edge?(file, exec), "autorequire edge was not created")
+    end
+  end
 
-        assert_raise(Puppet::Error) do
-            file.builddepends
-        end
+  # Testing #411.  It was a problem with builddepends.
+  def test_missing_deps
+    file = Puppet::Type.type(:file).new :path => tempfile, :require => Puppet::Resource.new("file", "/no/such/file")
+
+    assert_raise(Puppet::Error) do
+      file.builddepends
     end
+  end
 end