puppet 0.24.4 → 0.24.5

data/test/network/handler/configuration.rb

@@ -1,160 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppet/network/handler/configuration'
-
-class TestHandlerConfiguration < Test::Unit::TestCase
-	include PuppetTest
-
-    Config = Puppet::Network::Handler.handler(:configuration)
-
-    # Check all of the setup stuff.
-    def test_initialize
-        config = nil
-        assert_nothing_raised("Could not create local config") do
-            config = Config.new(:Local => true)
-        end
-
-        assert(config.local?, "Config is not considered local after being started that way")
-    end
-
-    # Test creation/returning of the interpreter
-    def test_interpreter
-        config = Config.new
-
-        # First test the defaults
-        config.expects(:create_interpreter).returns(:interp)
-        assert_equal(:interp, config.send(:interpreter), "Did not return the interpreter")
-
-        # Now run it again and make sure we get the same thing
-        assert_equal(:interp, config.send(:interpreter), "Did not cache the interpreter")
-    end
-
-    def test_create_interpreter
-        config = Config.new(:Local => false)
-        args = {}
-
-        # Try it first with defaults.
-        Puppet::Parser::Interpreter.expects(:new).returns(:interp)
-        assert_equal(:interp, config.send(:create_interpreter), "Did not return the interpreter")
-    end
-
-    # Make sure node objects get appropriate data added to them.
-    def test_add_node_data
-        # First with no classes
-        config = Config.new
-
-        fakenode = Object.new
-        # Set the server facts to something
-        config.instance_variable_set("@server_facts", :facts)
-        fakenode.expects(:merge).with(:facts)
-        config.send(:add_node_data, fakenode)
-
-        # Now try it with classes.
-        config.classes = %w{a b}
-        list = []
-        fakenode = Object.new
-        fakenode.expects(:merge).with(:facts)
-        fakenode.expects(:classes).returns(list).times(2)
-        config.send(:add_node_data, fakenode)
-        assert_equal(%w{a b}, list, "Did not add classes to node")
-    end
-
-    def test_compile
-        config = Config.new
-
-        # First do a local
-        node = mock 'node'
-        node.stubs(:name).returns(:mynode)
-        node.stubs(:environment).returns(:myenv)
-
-        interp = mock 'interpreter'
-        interp.stubs(:environment)
-        interp.expects(:compile).with(node).returns(:config)
-        config.expects(:interpreter).returns(interp)
-
-        Puppet.expects(:notice) # The log message from benchmarking
-
-        assert_equal(:config, config.send(:compile, node), "Did not return config")
-        
-        # Now try it non-local
-        node = mock 'node'
-        node.stubs(:name).returns(:mynode)
-        node.stubs(:environment).returns(:myenv)
-
-        interp = mock 'interpreter'
-        interp.stubs(:environment)
-        interp.expects(:compile).with(node).returns(:config)
-
-        config = Config.new(:Local => true)
-        config.expects(:interpreter).returns(interp)
-
-        assert_equal(:config, config.send(:compile, node), "Did not return config")
-    end
-
-    def test_set_server_facts
-        config = Config.new
-        assert_nothing_raised("Could not call :set_server_facts") do
-            config.send(:set_server_facts)
-        end
-        facts = config.instance_variable_get("@server_facts")
-        %w{servername serverversion serverip}.each do |fact|
-            assert(facts.include?(fact), "Config did not set %s fact" % fact)
-        end
-    end
-
-    def test_translate
-        # First do a local config
-        config = Config.new(:Local => true)
-        assert_equal(:plain, config.send(:translate, :plain), "Attempted to translate local config")
-
-        # Now a non-local
-        config = Config.new(:Local => false)
-        assert(! config.local?, "Config wrongly thinks it's local")
-        obj = mock 'dumpee'
-        yamld = mock 'yaml'
-        obj.expects(:to_yaml).with(:UseBlock => true).returns(yamld)
-        CGI.expects(:escape).with(yamld).returns(:translated)
-        assert_equal(:translated, config.send(:translate, obj), "Did not return translated config")
-    end
-
-    # Check that we're storing the node freshness into the rails db.  Hackilicious.
-    def test_update_node_check
-        # This is stupid.
-        config = Config.new
-        node = Object.new
-        node.expects(:name).returns(:hostname)
-        now = Object.new
-        Time.expects(:now).returns(now)
-        host = Object.new
-        host.expects(:last_freshcheck=).with(now)
-        host.expects(:save)
-
-        # Only test the case where rails is there
-        Puppet[:storeconfigs] = true
-        Puppet.features.expects(:rails?).returns(true)
-        Puppet::Rails.expects(:connect)
-        Puppet::Rails::Host.expects(:find_or_create_by_name).with(:hostname).returns(host)
-
-        config.send(:update_node_check, node)
-    end
-
-    def test_version
-        # First try the case where we can't look up the node
-        config = Config.new
-        node = Object.new
-        Puppet::Node.stubs(:find_by_any_name).with(:client).returns(false, node)
-        interp = Object.new
-        assert_instance_of(Bignum, config.version(:client), "Did not return configuration version")
-
-        # And then when we find the node.
-        config = Config.new
-        config.expects(:update_node_check).with(node)
-        interp = Object.new
-        interp.expects(:configuration_version).returns(:version)
-        config.expects(:interpreter).returns(interp)
-        assert_equal(:version, config.version(:client), "Did not return configuration version")
-    end
-end

data/test/other/propertychange.rb

@@ -1,140 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2006-12-21.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-
-class TestPropertyChange < Test::Unit::TestCase
-	include PuppetTest
-	class FakeProperty < Puppet::Property
-	    attr_accessor :is, :should, :resource
-	    attr_reader :noop
-	    def change_to_s(currentvalue, newvalue)
-	        "fake change"
-        end
-	    def insync?(is)
-	        is == @should
-        end
-        def log(msg)
-            Puppet::Util::Log.create(
-                :level => :info,
-                :source => self,
-                :message => msg
-            )
-        end
-        def noop
-            if defined? @noop
-                @noop
-            else
-                false
-            end
-        end
-        def path
-            "fakechange"
-        end
-        def should_to_s(newvalue)
-            newvalue.to_s
-        end
-        def sync
-            if insync?(@is)
-                return nil
-            else
-                @is = @should
-                return :fake_change
-            end
-        end
-        def to_s
-            path
-        end
-    end
-    
-    def mkchange
-        property = FakeProperty.new :resource => "fakeparent"
-        property.is = :start
-        property.should = :finish
-        property.resource = :parent
-        change = nil
-        assert_nothing_raised do
-            change = Puppet::PropertyChange.new(property, :start)
-        end
-        change.transaction = :trans
-        
-        assert_equal(:start, change.is, "@is did not get copied")
-        assert_equal(:finish, change.should, "@should did not get copied")
-        assert_equal(%w{fakechange change}, change.path, "path did not get set correctly")
-        
-        assert(! change.changed?, "change defaulted to already changed")
-        
-        return change
-    end
-    
-	def test_go
-	    change = mkchange
-	    
-	    coll = logcollector()
-	    
-	    events = nil
-	    # First make sure we get an immediate return 
-	    assert_nothing_raised do
-    	    events = change.go
-	    end
-	    assert_instance_of(Array, events, "events were not returned in an array")
-	    assert_instance_of(Puppet::Event, events[0], "event array did not contain events")
-
-	    event = events.shift
-	    {:event => :fake_change, :transaction => :trans, :source => :parent}.each do |method, val|
-	        assert_equal(val, event.send(method), "Event did not set %s correctly" % method)
-        end
-	    
-        # Disabled, because it fails when running the whole suite at once.
-        #assert(coll.detect { |l| l.message == "fake change" }, "Did not log change")
-	    assert_equal(change.property.is, change.property.should, "did not call sync method")
-	    
-	    # Now make sure that proxy sources can be set.
-	    assert_nothing_raised do
-    	    change.proxy = :other
-	    end
-	    # Reset, so we change again
-	    change.property.is = :start
-	    change.is = :start
-	    assert_nothing_raised do
-	        events = change.go
-        end
-        
-	    assert_instance_of(Array, events, "events were not returned in an array")
-	    assert_instance_of(Puppet::Event, events[0], "event array did not contain events")
-
-	    event = events.shift
-	    {:event => :fake_change, :transaction => :trans, :source => :other}.each do |method, val|
-	        assert_equal(val, event.send(method), "Event did not set %s correctly" % method)
-        end
-	    
-	    #assert(coll.detect { |l| l.message == "fake change" }, "Did not log change")
-	    assert_equal(change.property.is, change.property.should, "did not call sync method")
-    end
-
-    # Related to #542.  Make sure changes in noop mode produce the :noop event.
-    def test_noop_event
-        change = mkchange
-
-        assert(! change.skip?, "Change is already being skipped")
-
-        Puppet[:noop] = true
-
-        change.property.noop = true
-        assert(change.noop, "did not set noop")
-        assert(change.skip?, "setting noop did not mark change for skipping")
-
-        event = nil
-        assert_nothing_raised("Could not generate noop event") do
-            event = change.forward
-        end
-
-        assert_equal(1, event.length, "got wrong number of events")
-        assert_equal(:noop, event[0].event, "did not generate noop mode when in noop")
-    end
-end
-

data/test/util/loadedfile.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/util/loadedfile'
-require 'puppettest'
-
-class TestLoadedFile < Test::Unit::TestCase
-	include PuppetTest
-    def test_file
-        Puppet[:filetimeout] = 0
-        file = nil
-        path = tempfile()
-        File.open(path, "w") { |f| f.puts "yayness" }
-        assert_nothing_raised {
-            file = Puppet::Util::LoadedFile.new(path)
-        }
-
-        assert(!file.changed?, "File incorrectly returned changed")
-
-        File.open(path, "w") { |f| f.puts "booness" }
-        #file.tstamp = File.stat(path).ctime - 5
-        new = File.stat(path).ctime - 5
-        file.tstamp = new
-
-        assert(file.changed?, "File did not catch change")
-    end
-
-    def test_timeout
-        Puppet[:filetimeout] = 50
-        path = tempfile()
-
-        File.open(path, "w") { |f| f.puts "yay" }
-        file = nil
-        assert_nothing_raised {
-            file = Puppet::Util::LoadedFile.new(path)
-        }
-
-        assert_nothing_raised {
-            assert(!file.changed?,
-                "File thought it changed immediately")
-        }
-
-        sleep 1
-        File.open(path, "w") { |f| f.puts "yay" }
-        #file.tstamp = File.stat(path).ctime - 5
-
-        assert(!file.changed?,
-            "File was marked as changed too soon")
-
-        Puppet[:filetimeout] = 0
-        assert(file.changed?,
-            "File was not marked as changed soon enough")
-    end
-
-    def test_stamp
-        file = tempfile()
-        File.open(file, "w") { |f| f.puts "" }
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::Util::LoadedFile.new(file)
-        }
-
-        # Make sure we don't refresh
-        Puppet[:filetimeout] = 50
-
-        stamp = File.stat(file).ctime
-
-        assert_equal(stamp, obj.stamp)
-
-        sleep 1
-        # Now change the file, and make sure the stamp doesn't update yet
-        File.open(file, "w") { |f| f.puts "" }
-        assert_equal(stamp, obj.stamp,
-            "File prematurely refreshed")
-
-        Puppet[:filetimeout] = 0
-        assert_equal(File.stat(file).ctime, obj.stamp,
-            "File did not refresh")
-    end
-
-    # Testing #394.
-    def test_changed_missing_file
-        file = tempfile()
-        File.open(file, "w") { |f| f.puts "" }
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::Util::LoadedFile.new(file)
-        }
-        Puppet[:filetimeout] = -10
-
-        assert_nothing_raised {
-            obj.changed?
-        }
-
-        # Now remove the file
-        File.unlink(file)
-
-        assert_nothing_raised("removed file threw an error") {
-            assert(obj.changed?, "File was not considered changed when missing")
-        }
-    end
-
-    # Make sure negative values always result in change notifications.
-    def test_negative_always_changes
-        file = tempfile()
-        File.open(file, "w") { |f| f.puts "" }
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet::Util::LoadedFile.new(file)
-        }
-
-        assert(! obj.changed?, "file with no change considered changed")
-        # Now set a negative value
-        Puppet[:filetimeout] = -1
-
-        assert(obj.changed?, "negative file timeout did not disable checking")
-    end
-end
-