puppet 0.23.2 → 0.24.0

data/test/tagging/tagging.rb

@@ -1,170 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppet'
-require 'puppettest'
-require 'puppettest/parsertesting'
-require 'puppettest/resourcetesting'
-
-class TestTagging < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-
-    # Make sure the scopes are getting the right tags
-    def test_scopetags
-        scope = nil
-        assert_nothing_raised {
-            scope = mkscope
-            scope.name = "yayness"
-            scope.type = "solaris"
-        }
-
-        assert_nothing_raised {
-            assert_equal(%w{solaris}, scope.tags, "Incorrect scope tags")
-        }
-    end
-
-    # Test deeper tags, where a scope gets all of its parent scopes' tags
-    def test_deepscopetags
-        scope = nil
-        assert_nothing_raised {
-            scope = mkscope
-            scope.name = "yayness"
-            scope.type = "solaris"
-            scope = scope.newscope
-            scope.name = "booness"
-            scope.type = "apache"
-        }
-
-        assert_nothing_raised {
-            # Scopes put their own tags first
-            assert_equal(%w{apache solaris}, scope.tags, "Incorrect scope tags")
-        }
-    end
-
-    # Verify that the tags make their way to the objects
-    def test_objecttags
-        scope = nil
-        assert_nothing_raised {
-            scope = mkscope
-            scope.name = "yayness"
-            scope.type = "solaris"
-        }
-
-        resource = mkresource :type => "file", :title => "/tmp/testing",
-            :params => {:owner => "root"}, :file => "/yay", :line => 1,
-            :scope => scope
-
-        assert_nothing_raised {
-            scope.setresource(resource)
-        }
-
-        assert_nothing_raised {
-            assert_equal(%w{solaris file}, resource.tags,
-                "Incorrect tags")
-        }
-    end
-
-    # Make sure that specifying tags results in only those objects getting
-    # run.
-    def test_tagspecs
-        a = tempfile()
-        b = tempfile()
-
-        afile = Puppet.type(:file).create(
-            :path => a,
-            :ensure => :file
-        )
-        afile.tag("a")
-
-        bfile = Puppet.type(:file).create(
-            :path => b,
-            :ensure => :file
-        )
-        bfile.tag(:b)
-
-        # First, make sure they get created when no spec'ed tags
-        assert_events([:file_created,:file_created], afile, bfile)
-        assert(FileTest.exists?(a), "A did not get created")
-        assert(FileTest.exists?(b), "B did not get created")
-        File.unlink(a)
-        File.unlink(b)
-
-        # Set the tags to a
-        assert_nothing_raised {
-            Puppet[:tags] = "a"
-        }
-
-        assert_events([:file_created], afile, bfile)
-        assert(FileTest.exists?(a), "A did not get created")
-        assert(!FileTest.exists?(b), "B got created")
-        File.unlink(a)
-
-        # Set the tags to b
-        assert_nothing_raised {
-            Puppet[:tags] = "b"
-        }
-
-        assert_events([:file_created], afile, bfile)
-        assert(!FileTest.exists?(a), "A got created")
-        assert(FileTest.exists?(b), "B did not get created")
-        File.unlink(b)
-
-        # Set the tags to something else
-        assert_nothing_raised {
-            Puppet[:tags] = "c"
-        }
-
-        assert_events([], afile, bfile)
-        assert(!FileTest.exists?(a), "A got created")
-        assert(!FileTest.exists?(b), "B got created")
-
-        # Now set both tags
-        assert_nothing_raised {
-            Puppet[:tags] = "b, a"
-        }
-
-        assert_events([:file_created, :file_created], afile, bfile)
-        assert(FileTest.exists?(a), "A did not get created")
-        assert(FileTest.exists?(b), "B did not get created")
-        File.unlink(a)
-
-    end
-
-    def test_metaparamtag
-        path = tempfile()
-
-        start = %w{some tags}
-        tags = %w{a list of tags}
-
-        obj = nil
-        assert_nothing_raised do
-            obj = Puppet.type(:file).create(
-                :path => path,
-                :ensure => "file",
-                :tag => start
-            )
-        end
-
-
-        assert(obj, "Did not make object")
-
-        start.each do |tag|
-            assert(obj.tagged?(tag), "Object was not tagged with %s" % tag)
-        end
-
-        tags.each do |tag|
-            assert_nothing_raised {
-                obj[:tag] = tag
-            }
-        end
-
-        tags.each do |tag|
-            assert(obj.tagged?(tag), "Object was not tagged with %s" % tag)
-        end
-    end
-end
-
-# $Id: tagging.rb 1793 2006-10-16 22:01:40Z luke $

data/test/util/fact_store.rb

@@ -1,67 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-05-02.
-#  Copyright (c) 2007. All rights reserved.
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppet/util/fact_store'
-
-class TestFactStore < Test::Unit::TestCase
-	include PuppetTest
-	
-	def test_new_fact_store
-        klass = nil
-        assert_nothing_raised("Could not create fact store") do
-            klass = Puppet::Util::FactStore.newstore(:yay) do
-            end
-        end
-
-        assert_equal(klass, Puppet::Util::FactStore.store(:yay), "Did not get created store back by name")
-    end
-
-    def test_yaml_store
-        yaml = Puppet::Util::FactStore.store(:yaml)
-        assert(yaml, "Could not retrieve yaml store")
-
-        name = "node"
-        facts = {"a" => :b, :c => "d", :e => :f, "g" => "h"}
-
-        store = nil
-        assert_nothing_raised("Could not create YAML store instance") do
-            store = yaml.new 
-        end
-
-        assert_nothing_raised("Could not store host facts") do
-            store.set(name, facts)
-        end
-
-        dir = Puppet[:yamlfactdir]
-
-        file = File.join(dir, name + ".yaml")
-        assert(FileTest.exists?(file), "Did not create yaml file for node")
-
-        text = File.read(file)
-        newfacts = nil
-        assert_nothing_raised("Could not deserialize yaml") do
-            newfacts = YAML::load(text)
-        end
-
-        # Don't directly compare the hashes, because there might be extra
-        # data stored in the client hash
-        facts.each do |var, value|
-            assert_equal(value, newfacts[var], "Value for %s changed during storage" % var)
-        end
-
-        # Now make sure the facts get retrieved correctly
-        assert_nothing_raised("Could not retrieve facts") do
-            newfacts = store.get(name)
-        end
-
-        # Now make sure the hashes are equal, since internal facts should not be returned.
-        assert_equal(facts, newfacts, "Retrieved facts are not equal")
-    end
-end
-
-# $Id: fact_store.rb 2457 2007-05-03 05:24:13Z luke $

data/test/util/graph.rb

@@ -1,108 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2006-11-16.
-#  Copyright (c) 2006. All rights reserved.
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppettest/graph'
-require 'puppet/util/graph'
-
-class TestUtilGraph < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::Graph
-    
-	def test_to_graph
-	    children = %w{a b c d}
-        list = Container.new("yay", children)
-        
-        graph = nil
-        assert_nothing_raised do
-            graph = list.to_graph
-        end
-        
-        assert(graph.vertices.include?(list), "wtf?")
-        
-        ([list] + children).each do |thing|
-            assert(graph.vertex?(thing), "%s is not a vertex" % thing)
-        end
-        children.each do |child|
-            assert(graph.edge?(list, child),
-                "%s/%s was not added as an edge" % ["yay", child])
-        end
-    end
-    
-    def test_recursive_to_graph
-        one, two, three, middle, top = build_tree
-        
-        graph = nil
-        assert_nothing_raised do
-            graph = top.to_graph
-        end
-        
-        (%w{a b c d e f g h} + [one, two, middle, top]).each do |v|
-            assert(graph.vertex?(v), "%s is not a vertex" % v)
-        end
-        
-        [one, two, middle, top].each do |con|
-            con.each do |child|
-                assert(graph.edge?(con, child), "%s/%s is not an edge" % [con, child])
-            end
-        end
-        
-        # Now make sure we correctly retrieve the leaves from each container
-        {top => %w{a b c d e f g h i j},
-         one => %w{a b},
-         two => %w{c d},
-         three => %w{i j},
-         middle => %w{c d e f}}.each do |cont, list|
-            leaves = nil
-            assert_nothing_raised do
-                leaves = graph.leaves(cont)
-            end
-            leaves = leaves.sort
-            assert_equal(list.sort, leaves.sort,
-                "Got incorrect leaf list for %s" % cont.name)
-            %w{a b c d e f g h}.each do |letter|
-                unless list.include?(letter)
-                    assert(!leaves.include?(letter),
-                        "incorrectly got %s as a leaf of %s" %
-                            [letter, cont.to_s])
-                end
-            end
-        end
-    end
-    
-    def test_to_graph_with_block
-        middle = Container.new "middle", ["c", "d", 3, 4]
-        top = Container.new "top", ["a", "b", middle, 1, 2]
-        
-        graph = nil
-        assert_nothing_raised() { 
-            graph = top.to_graph { |c| c.is_a?(String) or c.is_a?(Container) }
-        }
-        
-        %w{a b c d}.each do |child|
-            assert(graph.vertex?(child), "%s was not added as a vertex" % child)
-        end
-        
-        [1, 2, 3, 4].each do |child|
-            assert(! graph.vertex?(child), "%s is a vertex" % child)
-        end
-    end
-
-    def test_cyclic_graphs
-        one = Container.new "one", %w{a b}
-        two = Container.new "two", %w{c d}
-        
-        one.push(two)
-        two.push(one)
-        
-        assert_raise(Puppet::Error, "did not fail on cyclic graph") do
-            one.to_graph
-        end
-    end
-end
-
-# $Id: graph.rb 2009 2007-01-01 21:08:45Z luke $