puppet 0.25.5 → 2.6.0

data/test/language/ast/selector.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2006-12-22.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/parsertesting'
-
-class TestSelector < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    AST = Puppet::Parser::AST
-
-    def test_evaluate
-        scope = mkscope
-        upperparam = nameobj("MYPARAM")
-        lowerparam = nameobj("myparam")
-
-        should = {"MYPARAM" => "upper", "myparam" => "lower"}
-
-        maker = Proc.new do
-            {
-            :default => AST::ResourceParam.new(:param => AST::Default.new(:value => "default"), :value => FakeAST.new("default")),
-            :lower => AST::ResourceParam.new(:param => FakeAST.new("myparam"), :value => FakeAST.new("lower")),
-            :upper => AST::ResourceParam.new(:param => FakeAST.new("MYPARAM"), :value => FakeAST.new("upper")),
-            }
-
-        end
-
-        # Start out case-sensitive
-        Puppet[:casesensitive] = true
-
-        %w{MYPARAM myparam}.each do |str|
-            param = nameobj(str)
-            params = maker.call()
-            sel = AST::Selector.new(:param => param, :values => params.values)
-            result = nil
-            assert_nothing_raised { result = sel.evaluate(scope) }
-            assert_equal(should[str], result, "did not case-sensitively match %s" % str)
-        end
-
-        # then insensitive
-        Puppet[:casesensitive] = false
-
-        %w{MYPARAM myparam}.each do |str|
-            param = nameobj(str)
-            params = maker.call()
-
-            # Delete the upper value, since we don't want it to match
-            # and it introduces a hash-ordering bug in testing.
-            params.delete(:upper)
-            sel = AST::Selector.new(:param => param, :values => params.values)
-            result = nil
-            assert_nothing_raised { result = sel.evaluate(scope) }
-            assert_equal("lower", result, "did not case-insensitively match %s" % str)
-        end
-    end
-end
-

data/test/language/resource.rb

@@ -1,172 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/resourcetesting'
-
-class TestResource < PuppetTest::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-    Parser = Puppet::Parser
-    AST = Parser::AST
-    Resource = Puppet::Parser::Resource
-    Reference = Puppet::Parser::Resource::Reference
-
-    def setup
-        super
-        Puppet[:trace] = false
-    end
-
-    def teardown
-        mocha_verify
-    end
-
-    # Make sure we paramcheck our params
-    def test_validate
-        res = mkresource
-        params = res.instance_variable_get("@params")
-        params[:one] = :two
-        params[:three] = :four
-        res.expects(:paramcheck).with(:one)
-        res.expects(:paramcheck).with(:three)
-        res.send(:validate)
-    end
-
-    def test_set_parameter
-        res = mkresource
-        params = res.instance_variable_get("@params")
-
-        # First test the simple case:  It's already a parameter
-        param = stub('param', :name => "pname")
-        param.expects(:is_a?).with(Resource::Param).returns(true)
-        res.send(:set_parameter, param)
-        assert_equal(param, params["pname"], "Parameter was not added to hash")
-
-        # Now the case where there's no value but it's not a param
-        param = mock('param')
-        param.expects(:is_a?).with(Resource::Param).returns(false)
-        assert_raise(ArgumentError, "Did not fail when a non-param was passed") do
-            res.send(:set_parameter, param)
-        end
-
-        # and the case where a value is passed in
-        param = stub :name => "pname", :value => "whatever"
-        Resource::Param.expects(:new).with(:name => "pname", :value => "myvalue", :source => res.source).returns(param)
-        res.send(:set_parameter, "pname", "myvalue")
-        assert_equal(param, params["pname"], "Did not put param in hash")
-    end
-
-    def test_paramcheck
-        # There are three cases here:
-
-        # It's a valid parameter
-        res = mkresource
-        ref = mock('ref')
-        res.instance_variable_set("@ref", ref)
-        klass = mock("class")
-        ref.expects(:typeclass).returns(klass).times(4)
-        klass.expects(:validattr?).with("good").returns(true)
-        assert(res.send(:paramcheck, :good), "Did not allow valid param")
-
-        # It's name or title
-        klass.expects(:validattr?).with("name").returns(false)
-        assert(res.send(:paramcheck, :name), "Did not allow name")
-        klass.expects(:validattr?).with("title").returns(false)
-        assert(res.send(:paramcheck, :title), "Did not allow title")
-
-        # It's not actually allowed
-        klass.expects(:validattr?).with("other").returns(false)
-        res.expects(:fail)
-        ref.expects(:type)
-        res.send(:paramcheck, :other)
-    end
-
-    def test_evaluate
-        # First try the most common case, we're not a builtin type.
-        res = mkresource
-        ref = res.instance_variable_get("@ref")
-        type = mock("type")
-        ref.expects(:definedtype).returns(type)
-        res.expects(:finish)
-        res.scope = mock("scope")
-
-        type.expects(:evaluate_code).with(res)
-
-        res.evaluate
-    end
-
-    def test_proxymethods
-        res = Parser::Resource.new :type => "evaltest", :title => "yay",
-            :source => mock("source"), :scope => mkscope
-
-        assert_equal("Evaltest", res.type)
-        assert_equal("yay", res.title)
-        assert_equal(false, res.builtin?)
-    end
-
-    # This is a bit of a weird one -- the user should not actually know
-    # that components exist, so we want references to act like they're not
-    # builtin
-    def test_components_are_not_builtin
-        ref = Parser::Resource::Reference.new(:type => "component", :title => "yay")
-
-        assert_nil(ref.builtintype, "Definition was considered builtin")
-    end
-
-    # The second part of #539 - make sure resources pass the arguments
-    # correctly.
-    def test_title_with_definitions
-        parser = mkparser
-        define = parser.newdefine "yayness",
-            :code => resourcedef("file", "/tmp",
-                "owner" => varref("name"), "mode" => varref("title"))
-
-
-        klass = parser.find_hostclass("", "")
-        should = {:name => :owner, :title => :mode}
-        [
-        {:name => "one", :title => "two"},
-        {:title => "three"},
-        ].each do |hash|
-            config = mkcompiler parser
-            args = {:type => "yayness", :title => hash[:title],
-                :source => klass, :scope => config.topscope}
-            if hash[:name]
-                args[:params] = {:name => hash[:name]}
-            else
-                args[:params] = {} # override the defaults
-            end
-
-            res = nil
-            assert_nothing_raised("Could not create res with %s" % hash.inspect) do
-                res = mkresource(args)
-            end
-            assert_nothing_raised("Could not eval res with %s" % hash.inspect) do
-                res.evaluate
-            end
-
-            made = config.topscope.findresource("File[/tmp]")
-            assert(made, "Did not create resource with %s" % hash.inspect)
-            should.each do |orig, param|
-                assert_equal(hash[orig] || hash[:title], made[param],
-                    "%s was not set correctly with %s" % [param, hash.inspect])
-            end
-        end
-    end
-
-    # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
-    def test_undef_and_to_hash
-        res = mkresource :type => "file", :title => "/tmp/testing",
-            :source => mock("source"), :scope => mkscope,
-            :params => {:owner => :undef, :mode => "755"}
-
-        hash = nil
-        assert_nothing_raised("Could not convert resource with undef to hash") do
-            hash = res.to_hash
-        end
-
-        assert_nil(hash[:owner], "got a value for an undef parameter")
-    end
-end

data/test/lib/puppettest/support/collection.rb

@@ -1,29 +0,0 @@
-
-module PuppetTest::Support::Collection
-    def run_collection_queries(form)
-        {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")}, %{group == bin},
-            %{title == "/tmp/testing" and group == bin}, %{title == bin or group == bin},
-            %{title == "/tmp/testing" or title == bin}, %{title == "/tmp/testing"},
-            %{(title == "/tmp/testing" or title == bin) and group == bin}],
-        false => [%{title == bin}, %{title == bin or (title == bin and group == bin)},
-            %{title != "/tmp/testing"}, %{title != "/tmp/testing" and group != bin}]
-        }.each do |res, ary|
-            ary.each do |str|
-                if form == :virtual
-                    code = "File <| #{str} |>"
-                else
-                    code = "File <<| #{str} |>>"
-                end
-                parser = mkparser
-                query = nil
-
-                assert_nothing_raised("Could not parse '#{str}'") do
-                    query = parser.parse(code).hostclass("").code[0].query
-                end
-
-                yield str, res, query
-            end
-        end
-    end
-end
-

data/test/network/client/resource.rb

@@ -1,52 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/support/utils'
-require 'puppettest/support/assertions'
-require 'puppet/network/client/resource'
-
-class TestResourceClient < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-    include PuppetTest::Support::Utils
-
-    def setup
-        super
-
-        Puppet::Type.type(:user).provider(:directoryservice).stubs(:get_macosx_version_major).returns "10.5"
-    end
-
-    def mkresourceserver
-        Puppet::Network::Handler.resource.new
-    end
-
-    def mkclient
-        client = Puppet::Network::Client.resource.new(:Resource => mkresourceserver)
-    end
-
-    def test_resources
-        file = tempfile()
-        text = "yayness\n"
-        File.open(file, "w") { |f| f.print text }
-
-        mkresourceserver()
-
-        client = mkclient()
-
-        # Test describing
-        tresource = client.describe("file", file)
-
-        assert(tresource, "Did not get response")
-
-        assert_instance_of(Puppet::TransObject, tresource)
-
-        resource = tresource.to_ral
-        assert_equal(File.stat(file).mode & 007777, resource[:mode], "Did not get mode")
-
-        # Now test applying
-        result = client.apply(tresource)
-        assert(FileTest.exists?(file), "File was not created on apply")
-    end
-end
-

data/test/network/handler/bucket.rb

@@ -1,313 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppet/network/handler/filebucket'
-require 'base64'
-require 'mocha'
-
-class TestBucket < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def out
-        if defined? @num
-            @num += 1
-        else
-            @num = 1
-        end
-
-        #Puppet.err "#{Process.pid}: %s: %s" % [@num, memory()]
-        #gcdebug(String)
-    end
-
-    # run through all of the files and exercise the filebucket methods
-    def checkfiles(client)
-        files = filelist()
-
-        # iterate across all of the files
-        files.each { |file|
-            Puppet.warning file
-            out
-            tempdir = tempfile()
-            Dir.mkdir(tempdir)
-            name = File.basename(file)
-            tmppath = File.join(tempdir,name)
-            @@tmpfiles << tmppath
-
-            out
-            # copy the files to our tmp directory so we can modify them...
-            FileUtils.cp(file, tmppath)
-
-            # make sure the copy worked
-            assert(FileTest.exists?(tmppath))
-
-            # backup both the orig file and the tmp file
-            osum = nil
-            tsum = nil
-            nsum = nil
-            out
-            assert_nothing_raised("Could not back up file") {
-                osum = client.backup(file)
-            }
-            out
-            assert_nothing_raised("Could not back up second file") {
-                tsum = client.backup(tmppath)
-            }
-            out
-
-            # verify you got the same sum back for both
-            assert(tsum == osum)
-
-            # modify our tmp file
-            unless FileTest.writable?(tmppath)
-                File.chmod(0644, tmppath)
-            end
-            File.open(tmppath,File::WRONLY|File::TRUNC) { |wf|
-                wf.print "This is some test text\n"
-            }
-            out
-
-            # back it up
-            assert_nothing_raised {
-                #STDERR.puts("backing up %s" % tmppath) if $debug
-                nsum = client.backup(tmppath)
-            }
-            out
-
-            # and verify the sum changed
-            assert(tsum != nsum)
-
-            # restore the orig
-            assert_nothing_raised {
-                nsum = client.restore(tmppath,tsum)
-            }
-            out
-
-            # and verify it actually got restored
-            contents = File.open(tmppath) { |rf|
-                #STDERR.puts("reading %s" % tmppath) if $debug
-                rf.read
-            }
-            out
-            csum = Digest::MD5.hexdigest(contents)
-            out
-            assert(tsum == csum)
-        }
-    end
-
-    # a list of files that should be on the system
-    # just something to test moving files around
-    def filelist
-        if defined? @files
-            return @files
-        else
-            @files = []
-        end
-
-        %w{
-            who bash sh uname /etc/passwd /etc/syslog.conf /etc/hosts
-        }.each { |file|
-            # if it's fully qualified, just add it
-            if file =~ /^\//
-                if FileTest.exists?(file)
-                    @files.push file
-                end
-            else
-                # else if it's unqualified, look for it in our path
-                begin
-                    path = %x{which #{file}}
-                rescue => detail
-                    #STDERR.puts "Could not search for binaries: %s" % detail
-                    next
-                end
-
-                if path != ""
-                    @files.push path.chomp
-                end
-            end
-        }
-
-        return @files
-    end
-
-    def setup
-        super
-        @bucket = tempfile()
-    end
-
-    #def teardown
-    #    system("lsof -p %s" % Process.pid)
-    #    super
-    #end
-
-    # test operating against the local filebucket object
-    # this calls the direct server methods, which are different than the
-    # Dipper methods
-    def test_localserver
-        files = filelist()
-        server = nil
-        assert_nothing_raised {
-            server = Puppet::Network::Handler.filebucket.new(
-                :Path => @bucket
-            )
-        }
-
-        # iterate across them...
-        files.each { |file|
-            contents = File.open(file) { |of| of.read }
-
-            md5 = nil
-
-            # add a file to the repository
-            assert_nothing_raised {
-                #STDERR.puts("adding %s" % file) if $debug
-                md5 = server.addfile(Base64.encode64(contents),file)
-            }
-
-            # and get it back again
-            newcontents = nil
-            assert_nothing_raised {
-                #STDERR.puts("getting %s" % file) if $debug
-                newcontents = Base64.decode64(server.getfile(md5))
-            }
-
-            # and then make sure they're still the same
-            assert(
-                contents == newcontents
-            )
-        }
-    end
-
-    # test with a server and a Dipper
-    def test_localboth
-        files = filelist()
-
-        bucket = nil
-        client = nil
-        threads = []
-        assert_nothing_raised {
-            bucket = Puppet::Network::Handler.filebucket.new(
-                :Path => @bucket
-            )
-        }
-
-        #sleep(30)
-        assert_nothing_raised {
-            client = Puppet::Network::Client.dipper.new(
-                :Bucket => bucket
-            )
-        }
-
-        #4.times { checkfiles(client) }
-        checkfiles(client)
-    end
-
-    def test_no_path_duplicates
-        bucket = nil
-        assert_nothing_raised {
-            bucket = Puppet::Network::Handler.filebucket.new(
-                :Path => @bucket
-            )
-        }
-
-        sum = nil
-        assert_nothing_raised {
-            sum = bucket.addfile("yayness", "/my/file")
-        }
-        assert_nothing_raised {
-            bucket.addfile("yayness", "/my/file")
-        }
-
-        a, b, pathfile = bucket.class.paths(bucket.path, sum)
-
-        assert(FileTest.exists?(pathfile), "No path file at %s" % pathfile)
-
-        assert_equal("/my/file\n", File.read(pathfile))
-    end
-
-    # #447 -- a flat file structure just won't suffice.
-    def test_deeper_filestructure
-        bucket = Puppet::Network::Handler.filebucket.new(:Path => @bucket)
-
-        text = "this is some text"
-        md5 = Digest::MD5.hexdigest(text)
-
-        olddir = File.join(@bucket, md5)
-        FileUtils.mkdir_p(olddir)
-        oldcontent = File.join(olddir, "contents")
-        File.open(oldcontent, "w") { |f| f.print text }
-
-        result = nil
-        assert_nothing_raised("Could not retrieve content from old structure") do
-            result = bucket.getfile(md5)
-        end
-        assert_equal(text, result, "old-style content is wrong")
-
-        text = "and this is some new text"
-        md5 = Digest::MD5.hexdigest(text)
-
-        dirs = File.join(md5[0..7].split(""))
-        dir = File.join(@bucket, dirs, md5)
-        filedir, contents, paths = bucket.class.paths(@bucket, md5)
-
-        assert_equal(dir, filedir, "did not use a deeper file structure")
-        assert_equal(File.join(dir, "contents"), contents,
-            "content path is not the deeper version")
-        assert_equal(File.join(dir, "paths"), paths,
-            "paths file path is not the deeper version")
-
-        # Store our new text and make sure it gets stored in the new location
-        path = "/some/fake/path"
-        assert_nothing_raised("Could not store text") do
-            bucket.addfile(text, path)
-        end
-        assert(FileTest.exists?(contents), "did not create content file")
-        assert_equal(text, File.read(contents), "content is not right")
-        assert(FileTest.exists?(paths), "did not create paths file")
-        assert(File.read(paths).include?(path), "paths file does not contain path")
-
-        # And make sure we get it back out again
-        assert_nothing_raised("Could not retrieve new-style content") do
-            result = bucket.getfile(md5)
-        end
-        assert_equal(text, result, "did not retrieve new content correctly")
-    end
-
-    def test_add_path
-        bucket = Puppet::Network::Handler.filebucket.new(:Path => @bucket)
-
-        file = tempfile()
-
-        assert(! FileTest.exists?(file), "file already exists")
-
-        path = "/some/thing"
-        assert_nothing_raised("Could not add path") do
-            bucket.send(:add_path, path, file)
-        end
-        assert_equal(path + "\n", File.read(file), "path was not added")
-
-        assert_nothing_raised("Could not add path second time") do
-            bucket.send(:add_path, path, file)
-        end
-        assert_equal(path + "\n", File.read(file), "path was duplicated")
-
-        # Now try a new path
-        newpath = "/another/path"
-        assert_nothing_raised("Could not add path second time") do
-            bucket.send(:add_path, newpath, file)
-        end
-        text = [path, newpath].join("\n") + "\n"
-        assert_equal(text, File.read(file), "path was duplicated")
-
-        assert_nothing_raised("Could not add path third time") do
-            bucket.send(:add_path, path, file)
-        end
-        assert_equal(text, File.read(file), "path was duplicated")
-        assert_nothing_raised("Could not add second path second time") do
-            bucket.send(:add_path, newpath, file)
-        end
-        assert_equal(text, File.read(file), "path was duplicated")
-    end
-end
-