puppet 0.18.4 → 0.22.4

data/test/other/provider.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+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")
+    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
+        return provider
+    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(@provider.suitable?, "Implementation was not considered suitable")
+        assert(@provider.default?, "Implementation was not considered a default")
+
+        assert_equal(@provider, @type.defaultprovider,
+                     "Did not correctly find default provider")
+
+    end
+
+    def test_provider_false_confine
+        assert_nothing_raised do
+            @provider.confine :false => false
+        end
+
+        assert(@provider.suitable?, "False did not check correctly")
+    end
+
+    def test_provider_true_confine
+        assert_nothing_raised do
+            @provider.confine :true => true
+        end
+
+        assert(@provider.suitable?, "True did not check correctly")
+
+        # Now check whether we multiple true things work
+        assert_nothing_raised do
+            @provider.confine :true => false
+            @provider.confine :true => true
+        end
+        assert(! @provider.suitable?, "One truth overrode another")
+    end
+
+    def test_provider_exists_confine
+        file = tempfile()
+
+        assert_nothing_raised do
+            @provider.confine :exists => file
+        end
+
+        assert(! @provider.suitable?, "Exists did not check correctly")
+        File.open(file, "w") { |f| f.puts "" }
+        assert(@provider.suitable?, "Exists did not find file correctly")
+    end
+
+    def test_provider_facts_confine
+        # Now check for multiple platforms
+        assert_nothing_raised do
+            @provider.confine :operatingsystem => [Facter["operatingsystem"].value, :yayos]
+            @provider.confine :operatingsystem => [:fakeos, :otheros]
+        end
+
+        assert(@provider.suitable?, "Implementation not considered suitable")
+    end
+
+    def test_provider_default
+        nondef = nil
+        assert_nothing_raised {
+            nondef = newprovider(:nondefault)
+        }
+
+        assert_nothing_raised do
+            @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
+        end
+
+        assert_equal(@provider.name, @type.defaultprovider.name, "Did not get right provider")
+
+        @type.suitableprovider
+    end
+
+    def test_subclassconfines
+        parent = newprovider("parentprovider")
+
+        # Now make a bad confine on the parent
+        parent.confine :exists => "/this/file/definitely/does/not/exist"
+
+        child = nil
+        assert_nothing_raised {
+            child = @type.provide("child", :parent => parent.name) {}
+        }
+
+        assert(child.suitable?, "Parent ruled out child")
+    end
+
+    def test_commands
+        parent = newprovider("parentprovider")
+
+        child = nil
+        assert_nothing_raised {
+            child = @type.provide("child", :parent => parent.name) {}
+        }
+
+        assert_nothing_raised {
+            child.commands :which => "which"
+        }
+
+        assert(child.command(:which), "Did not find 'which' 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
+end
+
+# $Id: provider.rb 1793 2006-10-16 22:01:40Z luke $

data/test/other/puppet.rb

@@ -1,21 +1,17 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
-require 'puppet/parsedfile'
 require 'puppettest'
-require 'test/unit'
 
 # Test the different features of the main puppet module
 class TestPuppetModule < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
     include SignalObserver
     
     def mkfakeclient
-        Class.new(Puppet::Client) do
+        Class.new(Puppet::Network::Client) do
             def initialize
             end
 
@@ -74,6 +70,63 @@ class TestPuppetModule < Test::Unit::TestCase
         assert(!obj.started?, "Object is still running")
 
     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"])
+    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")
+    end
+
+    def test_name
+        # Make sure it defaults to $0 without the rb
+        should = $0.gsub(/.+#{File::SEPARATOR}/,'').sub(/\.rb$/, '')
+
+        assert_equal(should, Puppet[:name], "default name was not right")
+
+        assert_nothing_raised("Could not reset name") do
+            Puppet[:name] = "puppetca"
+        end
+
+        assert_equal("puppetca", Puppet[:name], "name reset did not take")
+    end
 end
 
-# $Id: puppet.rb 1315 2006-06-27 05:15:51Z luke $
+# $Id: puppet.rb 2259 2007-03-06 19:03:05Z luke $

data/test/other/relationship.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-11-24.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/relationship'
+
+class TestRelationship < Test::Unit::TestCase
+    include PuppetTest
+    
+    def test_initialize
+        rel = Puppet::Relationship
+        
+        [["source", "target", "label"],
+         ["source", "target", {:event => :nothing}]
+        ].each do |ary|
+            # Make sure the label is required
+            assert_raise(Puppet::DevError) do
+                rel.new(*ary)
+            end
+        end
+    end
+    
+    def test_attributes
+        rel = Puppet::Relationship
+        
+        i = nil
+        assert_nothing_raised do
+            i = rel.new "source", "target", :event => :yay, :callback => :boo
+        end
+        
+        assert_equal(:yay, i.event, "event was not retrieved")
+        assert_equal(:boo, i.callback, "callback was not retrieved")
+        
+        # Now try it with nil values
+        assert_nothing_raised("failed to create with no event or callback") {
+            i = rel.new "source", "target"
+        }
+        
+        assert_nil(i.event, "event was not nil")
+        assert_nil(i.callback, "callback was not nil")
+    end
+
+    def test_match
+        edge = Puppet::Relationship.new(:a, :b)
+
+        assert(! edge.match?(:NONE), "nil event matched :NONE")
+        assert(! edge.match?(:ALL_EVENT), "nil event matched :ALL_EVENTS")
+        assert(! edge.match?(:random), "nil event matched random")
+
+        # Now set the edge to none
+        edge.label = {:event => :NONE}
+        assert(! edge.match?(:NONE), ":NONE event matched :NONE")
+        assert(! edge.match?(:ALL_EVENT), ":NONE event matched :ALL_EVENTS")
+        assert(! edge.match?(:random), ":NONE event matched random")
+
+        # Now set it to :ALL
+        edge.label = {:event => :ALL_EVENTS}
+        assert(! edge.match?(:NONE), ":ALL_EVENTS event matched :NONE")
+        assert(edge.match?(:ALL_EVENTS), ":ALL_EVENTS did not match :ALL_EVENTS")
+        assert(edge.match?(:random), ":ALL_EVENTS did not match random")
+
+        # And finally, :random
+        edge.label = {:event => :random}
+        assert(! edge.match?(:NONE), ":random event matched :NONE")
+        assert(! edge.match?(:ALL_EVENTS), ":random matched :ALL_EVENTS")
+        assert(edge.match?(:random), ":random did not match random")
+    end
+end
+
+# $Id: relationship.rb 1983 2006-12-29 04:15:36Z luke $

data/test/other/relationships.rb

@@ -1,15 +1,17 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
 
 class TestRelationships < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
+	def setup
+	    super
+	    Puppet::Type.type(:exec)
+    end
+    
     def newfile
         assert_nothing_raised() {
             return Puppet.type(:file).create(
@@ -18,126 +20,200 @@ class TestRelationships < Test::Unit::TestCase
             )
         }
     end
-
-    def test_simplerel
-        file1 = newfile()
-        file2 = newfile()
-        assert_nothing_raised {
-            file1[:require] = [file2.class.name, file2.name]
-        }
-
-        comp = newcomp(file1, file2)
-        comp.finalize
-        deps = []
-        assert_nothing_raised {
-            file1.eachdependency { |obj|
-                deps << obj
-            }
-        }
-
-        assert_equal(1, deps.length, "Did not get dependency")
-
-        assert_nothing_raised {
-            file1.unsubscribe(file2)
-        }
-
-        deps = []
-        assert_nothing_raised {
-            file1.eachdependency { |obj|
-                deps << obj
-            }
-        }
-
-        assert_equal(0, deps.length, "Still have dependency")
+    
+    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
+        
+        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
+        end
     end
 
-    def test_newsub
-        file1 = newfile()
-        file2 = newfile()
-
-        sub = nil
-        assert_nothing_raised("Could not create subscription") {
-            sub = Puppet::Event::Subscription.new(
-                :source => file1,
-                :target => file2,
-                :event => :ALL_EVENTS,
-                :callback => :refresh
-            )
-        }
-
-        subs = nil
-
-        assert_nothing_raised {
-            subs = Puppet::Event::Subscription.subscribers(file1)
-        }
-        assert_equal(1, subs.length, "Got incorrect number of subs")
-        assert_equal(sub.target, subs[0], "Got incorrect sub")
-
-        deps = nil
-        assert_nothing_raised {
-            deps = Puppet::Event::Subscription.dependencies(file2)
-        }
-        assert_equal(1, deps.length, "Got incorrect number of deps")
-        assert_equal(sub, deps[0], "Got incorrect dep")
+    # Make sure our various metaparams work correctly.  We're just checking
+    # here whether they correctly set up the callbacks and the direction of
+    # the relationship.
+    def test_relationship_metaparams
+        out = {:require => false, :subscribe => false,
+            :notify => true, :before => true}
+        refreshers = [:subscribe, :notify]
+        [:require, :subscribe, :notify, :before].each do |param|
+            # Create three files to generate our events and three
+            # execs to receive them
+            files = []
+            execs = []
+            3.times do |i|
+                files << Puppet::Type.newfile(
+                    :title => "file#{i}",
+                    :path => tempfile(),
+                    :ensure => :file
+                )
+
+                path = tempfile()
+                execs << Puppet::Type.newexec(
+                    :title => "notifytest#{i}",
+                    :path => "/usr/bin:/bin",
+                    :command => "touch #{path}",
+                    :refreshonly => true
+                )
+            end
+
+            # Add our first relationship
+            if out[param]
+                files[0][param] = execs[0]
+                sources = files[0]
+                targets = [execs[0]]
+            else
+                execs[0][param] = files[0]
+                sources = [files[0]]
+                targets = execs[0]
+            end
+            check_relationship(sources, targets, out[param], refreshers.include?(param))
+
+            # Now add another relationship
+            if out[param]
+                files[0][param] = execs[1]
+                targets << execs[1]
+                assert_equal(targets.collect { |t| [t.class.name, t.title]},
+                    files[0][param], "Incorrect target list")
+            else
+                execs[0][param] = files[1]
+                sources << files[1]
+                assert_equal(sources.collect { |t| [t.class.name, t.title]},
+                    execs[0][param], "Incorrect source list")
+            end
+            check_relationship(sources, targets, out[param], refreshers.include?(param))
+
+            Puppet::Type.allclear
+        end
     end
-
-    def test_eventmatch
-        file1 = newfile()
-        file2 = newfile()
-
-        sub = nil
-        assert_nothing_raised("Could not create subscription") {
-            sub = Puppet::Event::Subscription.new(
-                :source => file1,
-                :target => file2,
-                :event => :ALL_EVENTS,
-                :callback => :refresh
-            )
-        }
-
-        assert(sub.match?(:anything), "ALL_EVENTS did not match")
-        assert(! sub.match?(:NONE), "ALL_EVENTS matched :NONE")
-
-        sub.event = :file_created
-
-        assert(sub.match?(:file_created), "event did not match")
-        assert(sub.match?(:ALL_EVENTS), "ALL_EVENTS did not match")
-        assert(! sub.match?(:NONE), "ALL_EVENTS matched :NONE")
-
-        sub.event = :NONE
-
-        assert(! sub.match?(:file_created), "Invalid match")
-        assert(! sub.match?(:ALL_EVENTS), "ALL_EVENTS matched")
-        assert(! sub.match?(:NONE), "matched :NONE")
+    
+    def test_store_relationship
+        file = Puppet::Type.newfile :path => tempfile(), :mode => 0755
+        execs = []
+        3.times do |i|
+            execs << Puppet::Type.newexec(:title => "yay#{i}", :command => "/bin/echo yay")
+        end
+        
+        # First try it with one object, specified as a reference and an array
+        result = nil
+        [execs[0], [:exec, "yay0"], ["exec", "yay0"]].each do |target|
+            assert_nothing_raised do
+                result = file.send(:store_relationship, :require, target)
+            end
+        
+            assert_equal([[:exec, "yay0"]], result)
+        end
+        
+        # Now try it with multiple objects
+        symbols = execs.collect { |e| [e.class.name, e.title] }
+        strings = execs.collect { |e| [e.class.name.to_s, e.title] }
+        [execs, symbols, strings].each do |target|
+            assert_nothing_raised do
+                result = file.send(:store_relationship, :require, target)
+            end
+        
+            assert_equal(symbols, result)
+        end
+        
+        # Make sure we can mix it up, even though this shouldn't happen
+        assert_nothing_raised do
+            result = file.send(:store_relationship, :require, [execs[0], [execs[1].class.name, execs[1].title]])
+        end
+        
+        assert_equal([[:exec, "yay0"], [:exec, "yay1"]], result)
+        
+        # Finally, make sure that new results get added to old.  The only way
+        # to get rid of relationships is to delete the parameter.
+        file[:require] = execs[0]
+        
+        assert_nothing_raised do
+            result = file.send(:store_relationship, :require, [execs[1], execs[2]])
+        end
+        
+        assert_equal(symbols, result)
     end
-
-    def test_deletingsubs
-        file1 = newfile()
-        file2 = newfile()
-
-        file1[:subscribe] = [:file, file2.name]
-
-        comp = newcomp(file1, file2)
-        comp.finalize
-
-        assert(file1.requires?(file2))
-
-        assert_nothing_raised {
-            file1.unsubscribe(file2)
-        }
-        assert(!file1.requires?(file2))
-
-        # Now readd it, so we can use 'remove'
-        file1[:subscribe] = [:file, file2.name]
-        comp.finalize
-
-        assert_nothing_raised {
-            file1.remove
-        }
-
-        assert(!comp.include?(file1))
-        assert(!file2.subscribesto?(file1))
+    
+    def test_autorequire
+        # We know that execs autorequire their cwd, so we'll use that
+        path = tempfile()
+        
+        file = Puppet::Type.newfile(:title => "myfile", :path => path,
+            :ensure => :directory)
+        exec = Puppet::Type.newexec(:title => "myexec", :cwd => path,
+            :command => "/bin/echo")
+        
+        reqs = nil
+        assert_nothing_raised do
+            reqs = exec.autorequire
+        end
+        assert_equal([Puppet::Relationship[file, exec]], reqs)
+        
+        # Now make sure that these relationships are added to the transaction's
+        # relgraph
+        trans = Puppet::Transaction.new(newcomp(file, exec))
+        assert_nothing_raised do
+            trans.evaluate
+        end
+        
+        graph = trans.relgraph
+        assert(graph.edge?(file, exec), "autorequire edge was not created")
+    end
+    
+    def test_requires?
+        # Test the first direction
+        file1 = Puppet::Type.newfile(:title => "one", :path => tempfile,
+            :ensure => :directory)
+        file2 = Puppet::Type.newfile(:title => "two", :path => tempfile,
+            :ensure => :directory)
+        
+        file1[:require] = file2
+        assert(file1.requires?(file2), "requires? failed to catch :require relationship")
+        file1.delete(:require)
+        assert(! file1.requires?(file2), "did not delete relationship")
+        file1[:subscribe] = file2
+        assert(file1.requires?(file2), "requires? failed to catch :subscribe relationship")
+        file1.delete(:subscribe)
+        assert(! file1.requires?(file2), "did not delete relationship")
+        file2[:before] = file1
+        assert(file1.requires?(file2), "requires? failed to catch :before relationship")
+        file2.delete(:before)
+        assert(! file1.requires?(file2), "did not delete relationship")
+        file2[:notify] = file1
+        assert(file1.requires?(file2), "requires? failed to catch :notify relationship")
+    end
+    
+    # Testing #411.  It was a problem with builddepends.
+    def test_missing_deps
+        file = Puppet::Type.newfile :path => tempfile, :require => ["file", "/no/such/file"]
+        
+        assert_raise(Puppet::Error) do
+            file.builddepends
+        end
     end
 end
 
-# $Id: relationships.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: relationships.rb 2051 2007-01-05 05:12:37Z luke $