puppet 0.24.4 → 0.24.5

data/test/other/provider.rb

@@ -48,51 +48,6 @@ class TestImpl < Test::Unit::TestCase
 
     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 {

data/test/other/transactions.rb

@@ -72,11 +72,11 @@ class TestTransactions < Test::Unit::TestCase
         path1 = tempfile()
         path2 = tempfile()
         objects = []
-        objects << Puppet::Type.newfile(
+        objects << Puppet::Type.type(:file).create(
             :path => path1,
             :content => "yayness"
         )
-        objects << Puppet::Type.newfile(
+        objects << Puppet::Type.type(:file).create(
             :path => path2,
             :content => "booness"
         )
@@ -155,7 +155,7 @@ class TestTransactions < Test::Unit::TestCase
         path = tempfile()
         firstpath = tempfile()
         secondpath = tempfile()
-        file = Puppet::Type.newfile(:title => "file", :path => path, :content => "yayness")
+        file = Puppet::Type.type(:file).create(:title => "file", :path => path, :content => "yayness")
         first = Puppet::Type.newexec(:title => "first",
                                      :command => "/bin/echo first > #{firstpath}",
                                      :subscribe => [:file, path],
@@ -716,6 +716,45 @@ class TestTransactions < Test::Unit::TestCase
             "Not all resources were evaluated or not in the right order")
     end
 
+    # We need to generate resources before we prefetch them, else generated
+    # resources that require prefetching don't work.
+    def test_generate_before_prefetch
+        config = mk_catalog()
+        trans = Puppet::Transaction.new(config)
+
+        generate = nil
+        prefetch = nil
+        trans.expects(:generate).with { |*args| generate = Time.now; true }
+        trans.expects(:prefetch).with { |*args| ! generate.nil? }
+        trans.prepare
+        return
+
+        resource = Puppet::Type.type(:file).create :ensure => :present, :path => tempfile()
+        other_resource = mock 'generated'
+        def resource.generate
+            [other_resource]
+        end
+
+
+        config = mk_catalog(yay, rah)
+        trans = Puppet::Transaction.new(config)
+        
+        assert_nothing_raised do
+            trans.generate
+        end
+        
+        %w{ya ra y r}.each do |name|
+            assert(trans.catalog.vertex?(Puppet::Type.type(:generator)[name]),
+                "Generated %s was not a vertex" % name)
+            assert($finished.include?(name), "%s was not finished" % name)
+        end
+        
+        # Now make sure that cleanup gets rid of those generated types.
+        assert_nothing_raised do
+            trans.cleanup
+        end
+    end
+
     def test_ignore_tags?
         config = Puppet::Node::Catalog.new
         config.host_config = true
@@ -757,7 +796,7 @@ class TestTransactions < Test::Unit::TestCase
     def test_proxy_resources
         type = mkreducer do
             def evaluate
-                return Puppet::PropertyChange.new(Fakeprop.new(
+                return Puppet::Transaction::Change.new(Fakeprop.new(
                     :path => :path, :is => :is, :should => :should, :name => self.name, :resource => "a parent"), :is)
             end
         end
@@ -776,7 +815,7 @@ class TestTransactions < Test::Unit::TestCase
         assert(changes.length > 0, "did not get any changes")
         
         changes.each do |change|
-            assert_equal(resource, change.source, "change did not get proxy set correctly")
+            assert_equal(resource, change.resource, "change did not get proxy set correctly")
         end
     end
     
@@ -866,17 +905,16 @@ class TestTransactions < Test::Unit::TestCase
         assert(result, "c did not trigger anything")
         assert_instance_of(Array, result)
         event = result.shift
-        assert_instance_of(Puppet::Event, event)
-        assert_equal(:triggered, event.event, "event was not set correctly")
+        assert_instance_of(Puppet::Transaction::Event, event)
+        assert_equal(:triggered, event.name, "event was not set correctly")
         assert_equal(c, event.source, "source was not set correctly")
-        assert_equal(trans, event.transaction, "transaction was not set correctly")
 
         assert(trans.triggered?(c, :refresh),
             "Transaction did not store the trigger")
     end
     
     def test_set_target
-        file = Puppet::Type.newfile(:path => tempfile(), :content => "yay")
+        file = Puppet::Type.type(:file).create(:path => tempfile(), :content => "yay")
         exec1 = Puppet::Type.type(:exec).create :command => "/bin/echo exec1"
         exec2 = Puppet::Type.type(:exec).create :command => "/bin/echo exec2"
         trans = Puppet::Transaction.new(mk_catalog(file, exec1, exec2))
@@ -911,7 +949,7 @@ class TestTransactions < Test::Unit::TestCase
             Puppet::Type.rmtype(:norefresh)
         end
 
-        file = Puppet::Type.newfile :path => tempfile(), :content => "yay"
+        file = Puppet::Type.type(:file).create :path => tempfile(), :content => "yay"
         one = klass.create :name => "one", :subscribe => file
         
         assert_apply(file, one)
@@ -956,7 +994,7 @@ class TestTransactions < Test::Unit::TestCase
             newparam(:name) {}
             newproperty(:testing) do
                 def sync
-                    self.is = self.should
+                    # noop
                     :ran_testing
                 end
             end
@@ -989,8 +1027,8 @@ class TestTransactions < Test::Unit::TestCase
         # Now files
         d = tempfile()
         f = File.join(d, "file")
-        file = Puppet::Type.newfile(:path => f, :content => "yay")
-        dir = Puppet::Type.newfile(:path => d, :ensure => :directory, :require => file)
+        file = Puppet::Type.type(:file).create(:path => f, :content => "yay")
+        dir = Puppet::Type.type(:file).create(:path => d, :ensure => :directory, :require => file)
         
         rels[dir] = file
         rels.each do |after, before|
@@ -1014,7 +1052,7 @@ class TestTransactions < Test::Unit::TestCase
         path = tempfile
         epath = tempfile
         spath = tempfile
-        file = Puppet::Type.newfile(:path => path, :ensure => :file,
+        file = Puppet::Type.type(:file).create(:path => path, :ensure => :file,
             :title => "file")
         exec = Puppet::Type.type(:exec).create(:command => "touch %s" % epath,
             :path => ENV["PATH"], :subscribe => file, :refreshonly => true,
@@ -1052,7 +1090,7 @@ class TestTransactions < Test::Unit::TestCase
         3.times do |i|
             path = tempfile
             paths << path
-            file = Puppet::Type.newfile(:path => path, :ensure => :absent,
+            file = Puppet::Type.type(:file).create(:path => path, :ensure => :absent,
                 :backup => false, :title => "file%s" % i)
             File.open(path, "w") { |f| f.puts "" }
             files << file

data/test/rails/host.rb

@@ -151,41 +151,4 @@ class TestRailsHost < PuppetTest::TestCase
                 "loglevel was not added")
         end
     end
-
-    def test_freshness_connect_update
-        Puppet::Rails.init
-        Puppet[:storeconfigs] = true
-
-        Puppet[:code] = " "
-        # this is the default server setup
-        master = Puppet::Network::Handler.configuration.new(
-            :Local => true
-        )
-
-        # Create a host
-        Puppet::Rails::Host.new(:name => "test", :ip => "192.168.0.3").save
-
-        assert_nothing_raised("Failed to update last_connect for unknown host") do
-            master.version("created",'192.168.0.1')
-        end
-        
-        # Make sure it created the host
-        created = Puppet::Rails::Host.find_by_name("created")
-        assert(created, "Freshness did not create host")
-        assert(created.last_freshcheck,
-            "Did not set last_freshcheck on created host")
-
-        # Now check on the existing host
-        assert_nothing_raised("Failed to update last_connect for unknown host") do
-            master.version("test",'192.168.0.2')
-        end
-
-        # Recreate it, so we're not using the cached object.
-        host = Puppet::Rails::Host.find_by_name("test")
-        
-        # Make sure it created the host
-        assert(host.last_freshcheck,
-            "Did not set last_freshcheck on existing host")
-    end
 end
-

data/test/ral/providers/cron/crontab.rb

@@ -530,8 +530,6 @@ class TestCronParsedProvider < Test::Unit::TestCase
             @provider.initvars
             str += "\n"
             target.write(str)
-            assert_equal(str, target.read,
-                "Did not write correctly")
             assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
                 @provider.prefetch
             end
@@ -551,6 +549,11 @@ class TestCronParsedProvider < Test::Unit::TestCase
         end
     end
 
+    # #707
+    def test_write_freebsd_special
+        assert_equal(@provider.to_line(:record_type => :crontab, :ensure => :present, :special => "reboot", :command => "/bin/echo something"), "@reboot /bin/echo something")
+    end
+
     def test_prefetch
         cron = @type.create :command => "/bin/echo yay", :name => "test", :hour => 4
 
@@ -599,5 +602,31 @@ class TestCronParsedProvider < Test::Unit::TestCase
         result = target.read
         assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
     end
-end
 
+    # Testing #1216
+    def test_strange_lines
+        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+        text = " 5 \t\t 1,2 * 1 0 /bin/echo funtest"
+
+        records = nil
+        assert_nothing_raised {
+            records = @provider.parse(text)
+        }
+
+        should = {
+            :minute => %w{5},
+            :hour => %w{1 2},
+            :monthday => :absent,
+            :month => %w{1},
+            :weekday => %w{0},
+            :command => "/bin/echo funtest"
+        }
+
+        is = records.shift
+        assert(is, "Did not get record")
+
+        should.each do |p, v|
+            assert_equal(v, is[p], "did not parse %s correctly" % p)
+        end
+    end
+end

data/test/ral/providers/provider.rb

@@ -37,12 +37,13 @@ class TestProvider < Test::Unit::TestCase
         cleanup { Puppet::Type.rmtype(:provider_test) }
     end
 
-    def test_confine
-        provider = newprovider
+    def test_confine_defaults_to_suitable
 
-        assert(provider.suitable?,
-            "Marked unsuitable with no confines")
+        provider = newprovider
+        assert(provider.suitable?, "Marked unsuitable with no confines")
+    end
 
+    def test_confine_results
         {
             {:true => true} => true,
             {:true => false} => false,
@@ -54,6 +55,8 @@ class TestProvider < Test::Unit::TestCase
             {:exists => echo} => true,
             {:exists => "/this/file/does/not/exist"} => false,
         }.each do |hash, result|
+            provider = newprovider
+
             # First test :true
             hash.each do |test, val|
                 assert_nothing_raised do
@@ -61,19 +64,25 @@ class TestProvider < Test::Unit::TestCase
                 end
             end
 
-            assert_equal(result, provider.suitable?,
-                "Failed for %s" % [hash.inspect])
+            assert_equal(result, provider.suitable?, "Failed for %s" % [hash.inspect])
 
             provider.initvars
         end
+    end
+
+    def test_multiple_confines_do_not_override
+        provider = newprovider
 
         # Make sure multiple confines don't overwrite each other
         provider.confine :true => false
         assert(! provider.suitable?)
         provider.confine :true => true
         assert(! provider.suitable?)
+    end
 
-        provider.initvars
+    def test_one_failed_confine_is_sufficient
+
+        provider = newprovider
 
         # Make sure we test multiple of them, and that a single false wins
         provider.confine :true => true, :false => false
@@ -82,6 +91,18 @@ class TestProvider < Test::Unit::TestCase
         assert(! provider.suitable?)
     end
 
+    # #1197 - the binary should not be
+    def test_command_checks_for_binaries_each_time
+        provider = newprovider
+
+        provider.commands :testing => "/no/such/path"
+
+        provider.stubs(:binary).returns "/no/such/path"
+
+        provider.command(:testing)
+        assert_equal("/no/such/path", provider.command(:testing), "Did not return correct binary path")
+    end
+
     def test_command
         {:echo => "echo", :echo_with_path => echo, :missing => "nosuchcommand", :missing_qualified => "/path/to/nosuchcommand"}.each do |name, command|
             provider = newprovider

data/test/ral/type/filesources.rb

@@ -145,16 +145,7 @@ class TestFileSources < Test::Unit::TestCase
         # Make sure the munge didn't actually change the source
         assert_equal([source], property.should, "munging changed the source")
         
-        # First try it with a missing source
         currentvalue = nil
-        assert_nothing_raised do
-            currentvalue = property.retrieve
-        end
-        
-        # And make sure the property considers itself in sync, since there's nothing
-        # to do
-        assert(property.insync?(currentvalue), "source thinks there's work to do with no file or dest")
-        
         # Now make the dest a directory, and make sure the object sets :ensure
         # up to create a directory
         Dir.mkdir(source)
@@ -170,9 +161,6 @@ class TestFileSources < Test::Unit::TestCase
         
         # Now remove the source, and make sure :ensure was not modified
         Dir.rmdir(source)
-        assert_nothing_raised do
-            property.retrieve
-        end
         assert_equal(:directory, file.should(:ensure),
             "Did not keep :ensure setting")
         
@@ -208,10 +196,6 @@ class TestFileSources < Test::Unit::TestCase
         property = file.property(:source)
         assert(property, "did not get source property")
         
-        # Try it with no source at all
-        currentvalues = file.retrieve
-        assert(property.insync?(currentvalues[property]), "source property not in sync with missing source")
-
         # with a directory
         Dir.mkdir(source)
         currentvalues = file.retrieve
@@ -623,9 +607,9 @@ class TestFileSources < Test::Unit::TestCase
             :name => name
         )
 
-        assert_nothing_raised {
+        assert_raise Puppet::Error do 
             file.retrieve
-        }
+        end 
 
         comp = mk_catalog(file)
         comp.apply

data/test/ral/type/sshkey.rb

@@ -3,7 +3,6 @@
 require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
-require 'puppet/type/sshkey'
 require 'facter'
 
 class TestSSHKey < Test::Unit::TestCase

data/test/ral/type/user.rb

@@ -362,6 +362,12 @@ class TestUser < Test::Unit::TestCase
         user.delete(:groups)
     end
 
+    def test_groups_list_must_not_contain_commas
+        assert_raise(Puppet::Error) do
+            Puppet::Type.type(:user).create :name => "luke", :groups => "root,adm"
+        end
+    end
+
     def test_autorequire
         file = tempfile()
         comp = nil

data/test/test

@@ -0,0 +1,241 @@
+#!/usr/bin/env ruby
+
+#
+# = Synopsis
+#
+# Run unit tests, usually with the goal of resolving some conflict
+# between tests.
+#
+# = Usage
+#
+#   test [-d|--debug] [-f|--files] [-h|--help] [-n method] [-v|--verbose] <file> [file] ...
+#
+# = Description
+#
+# This script is useful for running a specific subset of unit tests, especially
+# when attempting to find a conflict between tests.  By default, it will take
+# the first argument you pass it and run that test or test directory with each
+# test directory in turn, looking for a failure.  If any tests fail, then
+# the script will drill into that test directory, looking for the specific conflict.
+#
+# In this way, when you have deduced you have two conflicting unit tests (tests which
+# pass in isolation but fail when run together), you can tell this script where
+# the failure is and leave it alone to find the conflict.
+#
+# This script is different from the Rakefile because it will run all tests in
+# a single process, whereas if you ask the Rakefile to run multiple tests, it will
+# run them in separate processes thus making it impossible to find conflicts.
+#
+# = Examples
+#
+# Attempt to resolve a conflict between a single test suite that could be anywhere:
+#
+#   ./test ral/providers/user.rb
+#
+# Determine whether two individual files conflict:
+#
+#   ./test --files language/functions.rb ral/providers/provider.rb
+#
+# Run the same test, but only run a specific unit test:
+#
+#   ./test -d -n test_search --files language/functions.rb ral/providers/provider.rb
+#
+# = Options
+#
+# debug::
+#   Enable full debugging.
+#
+# files::
+#   Specify exactly which files to test.
+#
+# help::
+#   Print this help message
+#
+# n::
+#   Specify a single unit test to run.  You can still specify as many files
+#   as you want.
+#
+# verbose::
+#   Print extra information.
+#
+# = Example
+#
+#   puppet -l /tmp/script.log script.pp
+#
+# = Author
+#
+# Luke Kanies
+#
+# = Copyright
+#
+# Copyright (c) 2005 Reductive Labs, LLC
+# Licensed under the GNU Public License
+
+require 'find'
+require 'getoptlong'
+include Find
+
+result = GetoptLong.new(
+    [ "--debug",	"-d",			GetoptLong::NO_ARGUMENT ],
+    [ "--verbose",	"-v",			GetoptLong::NO_ARGUMENT ],
+    [ "-n",			                GetoptLong::REQUIRED_ARGUMENT ],
+    [ "--files",    "-f",           GetoptLong::NO_ARGUMENT ],
+    [ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
+)
+
+usage = "USAGE: %s [--help] suite" % $0
+
+$options = {}
+keep = []
+
+result.each { |opt,arg|
+    case opt
+    when "--verbose"
+        $options[:verbose] = true
+    when "--files"
+        $options[:files] = true
+    when "--debug"
+        $options[:debug] = true
+        $options[:verbose] = true
+    when "--help"
+        puts usage
+        exit
+    else
+        keep << opt
+        keep << arg if arg
+    end
+}
+
+def dirs
+    Dir.glob("*").find_all { |d| FileTest.directory?(d) }.reject { |d|
+        ["lib", "data"].include?(d)
+    }
+end
+
+def rake(*args)
+    print "trying %s..." % args.join(" ")
+    output = %x{rake %s} % args.join(" ")
+
+    if $?.exitstatus == 0
+        puts "succeeded"
+        return true
+    else
+        puts "failed"
+        return false
+    end
+end
+
+def resolve(dir)
+    dirs = dirs()
+
+    # If the passed dir is a subdir or file, put the basedir last
+    if dir.include?(File::SEPARATOR)
+        basedir = dir.split(File::SEPARATOR)[0]
+        if dirs.include?(basedir)
+            dirs.delete(basedir) 
+            dirs << basedir
+        end
+    end
+
+    failed = nil
+    dirs.each do |d|
+        next if d == dir
+        unless run([d, dir])
+            failed = d
+            break
+        end
+    end
+    puts "%s failed" % failed
+
+    files = ruby_files(failed)
+
+    files.each do |file|
+        unless run([file, dir])
+            puts file
+            exit(0)
+        end
+    end
+
+    exit(1)
+end
+
+def ruby_files(dir)
+    files = []
+    # First collect the entire file list.
+    begin
+        find(dir) { |f| files << f if f =~ /\.rb$/ }
+    rescue => detail
+        puts "could not find on %s: %s" % [dir.inspect, detail]
+    end
+    files
+end
+
+def run(files, flags = nil)
+    args = %w{ruby}
+    args << "-Ilib:../lib"
+    args << "lib/rake/puppet_test_loader.rb"
+    if flags
+        args += flags
+    end
+    args += ARGV
+
+    print files.join(" ") + "... "
+    $stdout.flush
+
+    files.each do |file|
+        case File.stat(file).ftype
+        when "file": args << file
+        when "directory": args += ruby_files(file)
+        else
+            $stderr.puts "Skipping %s; can't handle %s" %
+                [file, File.stat(file).ftype]
+        end
+    end
+    args = args.join(" ")
+    if $options[:verbose]
+        p args
+    end
+    output = %x{#{args} 2>&1}
+    if $options[:debug]
+        print output
+    end
+
+    if $?.exitstatus == 0
+        puts "succeeded"
+        return true
+    else
+        puts "failed"
+        puts output
+        return false
+    end
+end
+
+if $options[:files]
+    run(ARGV, keep)
+else
+    dir = ARGV.shift
+
+    unless dir
+        $stderr.puts usage
+        exit(1)
+    end
+    resolve(dir)
+end
+#
+#
+#files = []
+#
+#args.each do |test|
+#    if FileTest.directory?(test)
+#        files += ruby_files(test)
+#    end
+#end
+
+## Now load all of our files.
+#files.each do |file|
+#    load file unless file =~ /^-/
+#end
+#
+#runner = Test::Unit::AutoRunner.new(false) 
+#runner.process_args
+#runner.run