puppet 0.24.9 → 0.25.0

data/spec/unit/other/pgraph.rb

@@ -1,210 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-9-12.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/pgraph'
-require 'puppet/util/graph'
-
-class Container
-    include Puppet::Util::Graph
-    include Enumerable
-    attr_accessor :name
-    def each
-        @children.each do |c| yield c end
-    end
-    
-    def initialize(name, ary)
-        @name = name
-        @children = ary
-    end
-    
-    def push(*ary)
-        ary.each { |c| @children.push(c)}
-    end
-    
-    def to_s
-        @name
-    end
-end
-
-describe Puppet::PGraph do
-    before do
-        @graph = Puppet::PGraph.new
-    end
-
-    it "should correctly clear vertices and edges when asked" do
-	    @graph.add_edge("a", "b")
-	    @graph.add_vertex "c"
-        @graph.clear
-        @graph.vertices.should be_empty
-        @graph.edges.should be_empty
-    end
-end
-
-describe Puppet::PGraph, " when matching edges" do
-    before do
-        @graph = Puppet::PGraph.new
-	    @event = Puppet::Transaction::Event.new(:yay, "a")
-	    @none = Puppet::Transaction::Event.new(:NONE, "a")
-
-	    @edges = {}
-	    @edges["a/b"] = Puppet::Relationship.new("a", "b", {:event => :yay, :callback => :refresh})
-	    @edges["a/c"] = Puppet::Relationship.new("a", "c", {:event => :yay, :callback => :refresh})
-	    @graph.add_edge(@edges["a/b"])
-    end
-
-    it "should match edges whose source matches the source of the event" do
-	    @graph.matching_edges([@event]).should == [@edges["a/b"]]
-    end
-
-    it "should match always match nothing when the event is :NONE" do
-	    @graph.matching_edges([@none]).should be_empty
-    end
-
-    it "should match multiple edges" do
-	    @graph.add_edge(@edges["a/c"])
-        edges = @graph.matching_edges([@event])
-        edges.should be_include(@edges["a/b"])
-        edges.should be_include(@edges["a/c"])
-    end
-end
-
-describe Puppet::PGraph, " when determining dependencies" do
-    before do
-        @graph = Puppet::PGraph.new
-        
-        @graph.add_edge("a", "b")
-        @graph.add_edge("a", "c")
-        @graph.add_edge("b", "d")
-    end
-
-    it "should find all dependents when they are on multiple levels" do
-        @graph.dependents("a").sort.should == %w{b c d}.sort
-    end
-
-    it "should find single dependents" do
-        @graph.dependents("b").sort.should == %w{d}.sort
-    end
-
-    it "should return an empty array when there are no dependents" do
-        @graph.dependents("c").sort.should == [].sort
-    end
-
-    it "should find all dependencies when they are on multiple levels" do
-        @graph.dependencies("d").sort.should == %w{a b}
-    end
-
-    it "should find single dependencies" do
-        @graph.dependencies("c").sort.should == %w{a}
-    end
-    
-    it "should return an empty array when there are no dependencies" do
-        @graph.dependencies("a").sort.should == []
-    end
-end
-
-describe Puppet::PGraph, " when splicing the relationship graph" do
-    def container_graph
-        @one = Container.new("one", %w{a b})
-        @two = Container.new("two", ["c", "d"])
-        @three = Container.new("three", ["i", "j"])
-        @middle = Container.new("middle", ["e", "f", @two])
-        @top = Container.new("top", ["g", "h", @middle, @one, @three])
-        @empty = Container.new("empty", [])
-
-        @contgraph = @top.to_graph
-
-        # We have to add the container to the main graph, else it won't
-        # be spliced in the dependency graph.
-        @contgraph.add_vertex(@empty)
-    end
-
-    def dependency_graph
-        @depgraph = Puppet::PGraph.new
-        @contgraph.vertices.each do |v|
-            @depgraph.add_vertex(v)
-        end
-
-        # We have to specify a relationship to our empty container, else it
-        # never makes it into the dep graph in the first place.
-        {@one => @two, "f" => "c", "h" => @middle, "c" => @empty}.each do |source, target|
-            @depgraph.add_edge(source, target, :callback => :refresh)
-        end
-    end
-
-    def splice
-        @depgraph.splice!(@contgraph, Container)
-    end
-
-    before do
-        container_graph
-        dependency_graph
-        splice
-    end
-
-    # This is the real heart of splicing -- replacing all containers in
-    # our relationship and exploding their relationships so that each
-    # relationship to a container gets copied to all of its children.
-    it "should remove all Container objects from the dependency graph" do
-        @depgraph.vertices.find_all { |v| v.is_a?(Container) }.should be_empty
-    end
-
-    it "should add container relationships to contained objects" do
-        @contgraph.leaves(@middle).each do |leaf|
-            @depgraph.should be_edge("h", leaf)
-        end
-    end
-
-    it "should explode container-to-container relationships, making edges between all respective contained objects" do
-        @one.each do |oobj|
-            @two.each do |tobj|
-                @depgraph.should be_edge(oobj, tobj)
-            end
-        end
-    end
-
-    it "should no longer contain anything but the non-container objects" do
-        @depgraph.vertices.find_all { |v| ! v.is_a?(String) }.should be_empty
-    end
-
-    it "should copy labels" do
-        @depgraph.edges.each do |edge|
-            edge.label.should == {:callback => :refresh}
-        end
-    end
-
-    it "should not add labels to edges that have none" do
-        @depgraph.add_edge(@two, @three)
-        splice
-        @depgraph.edge_label("c", "i").should == {}
-    end
-
-    it "should copy labels over edges that have none" do
-        @depgraph.add_edge("c", @three, {:callback => :refresh})
-        splice
-        # And make sure the label got copied.
-        @depgraph.edge_label("c", "i").should == {:callback => :refresh}
-    end
-
-    it "should not replace a label with a nil label" do
-        # Lastly, add some new label-less edges and make sure the label stays.
-        @depgraph.add_edge(@middle, @three)
-        @depgraph.add_edge("c", @three, {:callback => :refresh})
-        splice
-        @depgraph.edge_label("c", "i").should == {:callback => :refresh}
-    end
-
-    it "should copy labels to all created edges" do
-        @depgraph.add_edge(@middle, @three)
-        @depgraph.add_edge("c", @three, {:callback => :refresh})
-        splice
-        @three.each do |child|
-            edge = Puppet::Relationship.new("c", child)
-            @depgraph.should be_edge(edge.source, edge.target)
-            @depgraph.edge_label(edge.source, edge.target).should == {:callback => :refresh}
-        end
-    end
-end

data/spec/unit/resource_reference.rb

@@ -1,73 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-require 'puppet/resource_reference'
-
-describe Puppet::ResourceReference do
-    it "should have a :title attribute" do
-        Puppet::ResourceReference.new(:file, "foo").title.should == "foo"
-    end
-
-    it "should canonize types to capitalized strings" do
-        Puppet::ResourceReference.new(:file, "foo").type.should == "File"
-    end
-
-    it "should canonize qualified types so all strings are capitalized" do
-        Puppet::ResourceReference.new("foo::bar", "foo").type.should == "Foo::Bar"
-    end
-
-    it "should set its type to 'Class' and its title to the passed title if the passed type is :component and the title has no square brackets in it" do
-        ref = Puppet::ResourceReference.new(:component, "foo")
-        ref.type.should == "Class"
-        ref.title.should == "foo"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is :component and the title contains square brackets" do
-        ref = Puppet::ResourceReference.new(:component, "foo::bar[yay]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should == "yay"
-    end
-
-    it "should set the type to 'Class' if it is nil and the title contains no square brackets" do
-        ref = Puppet::ResourceReference.new(nil, "yay")
-        ref.type.should == "Class"
-        ref.title.should == "yay"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains square brackets" do
-        ref = Puppet::ResourceReference.new(nil, "foo::bar[yay]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should == "yay"
-    end
-
-    it "should interpret the title as a reference and assign appropriately if the type is nil and the title contains nested square brackets" do
-        ref = Puppet::ResourceReference.new(nil, "foo::bar[baz[yay]]")
-        ref.type.should == "Foo::Bar"
-        ref.title.should =="baz[yay]"
-    end
-end
-
-describe Puppet::ResourceReference, "when resolving resources without a catalog" do
-    it "should be able to resolve builtin resources from their types" do
-        Puppet::Type.type(:file).expects(:[]).with("myfile").returns(:myfile)
-        Puppet::ResourceReference.new(:file, "myfile").resolve.should == :myfile
-    end
-
-    it "should be able to resolve defined resources from Components" do
-        Puppet::Type.type(:component).expects(:[]).with("Foo::Bar[yay]").returns(:mything)
-        Puppet::ResourceReference.new("foo::bar", "yay").resolve.should == :mything
-    end
-end
-
-describe Puppet::ResourceReference, "when resolving resources with a catalog" do
-    it "should resolve all resources using the catalog" do
-        config = mock 'catalog'
-        ref = Puppet::ResourceReference.new("foo::bar", "yay")
-        ref.catalog = config
-
-        config.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
-
-        ref.resolve.should == :myresource
-    end
-end

data/spec/unit/util/uri_helper.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-10-18.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/util/uri_helper'
-
-describe Puppet::Util::URIHelper, " when converting a key to a URI" do
-    before do
-        @helper = Object.new
-        @helper.extend(Puppet::Util::URIHelper)
-    end
-
-    it "should return the URI instance" do
-        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
-        @helper.key2uri("/myhost/blah").should == :myuri
-    end
-
-    it "should escape the key before parsing" do
-        URI.expects(:escape).with("mykey").returns("http://myhost/blah")
-        URI.expects(:parse).with("http://myhost/blah").returns(:myuri)
-        @helper.key2uri("mykey").should == :myuri
-    end
-
-    it "should use the URI class to parse the key" do
-        URI.expects(:parse).with("http://myhost/blah").returns(:myuri)
-        @helper.key2uri("http://myhost/blah").should == :myuri
-    end
-
-    it "should set the scheme to 'file' if the key is a fully qualified path" do
-        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
-        @helper.key2uri("/myhost/blah").should == :myuri
-    end
-
-    it "should set the host to 'nil' if the key is a fully qualified path" do
-        URI.expects(:parse).with("file:///myhost/blah").returns(:myuri)
-        @helper.key2uri("/myhost/blah").should == :myuri
-    end
-end

data/test/data/snippets/ifexpression.rb

@@ -1,6 +0,0 @@
-$one = 1
-$two = 2
-
-if ($one < $two) and (($two < 3) or ($two == 2)) {
-    notice("True!")
-}

data/test/executables/filebucket.rb

@@ -1,51 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/network/client'
-require 'puppettest'
-require 'socket'
-require 'facter'
-
-class TestFileBucketExe < Test::Unit::TestCase
-    include PuppetTest::ExeTest
-
-    def test_local
-        basedir = tempfile()
-        FileUtils.mkdir_p(basedir)
-
-        bucket = tempfile
-        file = tempfile
-        text = "somet ext"
-        md5 = Digest::MD5.hexdigest(text)
-        File.open(file, "w") { |f| f.print text }
-        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} backup #{file}}
-
-        outfile, outmd5 = out.chomp.split(": ")
-
-        assert_equal(0, $?, "filebucket did not run successfully")
-
-        assert_equal(file, outfile, "did not output correct file name")
-        assert_equal(md5, outmd5, "did not output correct md5 sum")
-
-        dipper = Puppet::Network::Client.dipper.new(:Path => bucket)
-
-        newtext = nil
-        assert_nothing_raised("Could not get file from bucket") do
-            newtext = dipper.getfile(md5)
-        end
-
-        assert_equal(text, newtext, "did not get correct file from md5 sum")
-
-        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} get #{md5}}
-        assert_equal(0, $?, "filebucket did not run successfully")
-        assert_equal(text, out, "did not get correct text back from filebucket")
-
-        File.open(file, "w") { |f| f.puts "some other txt" }
-        out = %x{filebucket --confdir #{basedir} --vardir #{basedir} --bucket #{bucket} restore #{file} #{md5}}
-        assert_equal(0, $?, "filebucket did not run successfully")
-        assert_equal(text, File.read(file), "file was not restored")
-    end
-end
-

data/test/executables/puppetbin.rb

@@ -1,104 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-
-class TestPuppetBin < Test::Unit::TestCase
-    include PuppetTest::ExeTest
-    def test_version
-        output = nil
-        assert_nothing_raised {
-          output = %x{puppet --version}.chomp
-        }
-        assert_equal(Puppet.version, output)
-    end
-
-    def test_execution
-        file = mktestmanifest()
-
-        output = nil
-        cmd = "puppet"
-        if Puppet[:debug]
-            cmd += " --debug"
-        end
-        cmd += " --confdir %s" % Puppet[:confdir]
-        cmd += " --vardir %s" % Puppet[:vardir]
-        unless Puppet[:debug]
-            cmd += " --logdest %s" % "/dev/null"
-        end
-
-        assert_nothing_raised {
-            output = %x{#{cmd + " " + file} 2>&1}
-        }
-        assert($? == 0, "Puppet exited with code %s" % $?.to_i)
-
-        assert(FileTest.exists?(@createdfile), "Failed to create config'ed file")
-    end
-
-    def test_inlineexecution
-        path = tempfile()
-        code = "file { '#{path}': ensure => file }"
-
-        output = nil
-        cmd = "puppet"
-        if Puppet[:debug]
-            cmd += " --debug"
-        end
-        #cmd += " --fqdn %s" % fqdn
-        cmd += " --confdir %s" % Puppet[:confdir]
-        cmd += " --vardir %s" % Puppet[:vardir]
-        unless Puppet[:debug]
-            cmd += " --logdest %s" % "/dev/null"
-        end
-
-        cmd += " -e \"#{code}\""
-
-        assert_nothing_raised {
-            out = %x{#{cmd} 2>&1}
-        }
-        assert($? == 0, "Puppet exited with code %s" % $?.to_i)
-
-        assert(FileTest.exists?(path), "Failed to create config'ed file")
-    end
-
-    def test_stdin_execution
-        path = tempfile()
-        manifest = tempfile()
-        env = %x{which env}.chomp
-        if env == ""
-            Puppet.info "cannot find env; cannot test stdin_execution"
-            return
-        end
-        File.open(manifest, "w") do |f|
-            f.puts "#!#{env} puppet
-            exec { '/bin/touch #{path}': }"
-        end
-        File.chmod(0755, manifest)
-
-        assert_nothing_raised {
-            out = %x{#{manifest} 2>&1}
-        }
-        assert($? == 0, "manifest exited with code %s" % $?.to_i)
-
-        assert(FileTest.exists?(path), "Failed to create config'ed file")
-    end
-
-    def test_parseonly
-        path = tempfile()
-        manifest = tempfile()
-        puppet = %x{which puppet}.chomp
-        if puppet == ""
-            Puppet.info "cannot find puppet; cannot test parseonly"
-            return
-        end
-        code = 'File <<| |>>
-        include nosuchclass'
-
-        assert_nothing_raised {
-            IO.popen("#{puppet} --parseonly", 'w') { |p| p.puts code }
-        }
-        assert($? == 0, "parseonly test exited with code %s" % $?.to_i)
-    end
-end
-