puppet 0.25.5 → 2.6.0

data/spec/unit/util/tagging.rb

@@ -1,102 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2008-01-19.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/util/tagging'
-
-describe Puppet::Util::Tagging, "when adding tags" do
-    before do
-        @tagger = Object.new
-        @tagger.extend(Puppet::Util::Tagging)
-    end
-
-    it "should have a method for adding tags" do
-        @tagger.should be_respond_to(:tag)
-    end
-
-    it "should have a method for returning all tags" do
-        @tagger.should be_respond_to(:tags)
-    end
-
-    it "should add tags to the returned tag list" do
-        @tagger.tag("one")
-        @tagger.tags.should be_include("one")
-    end
-
-    it "should not add duplicate tags to the returned tag list" do
-        @tagger.tag("one")
-        @tagger.tag("one")
-        @tagger.tags.should == ["one"]
-    end
-
-    it "should return a duplicate of the tag list, rather than the original" do
-        @tagger.tag("one")
-        tags = @tagger.tags
-        tags << "two"
-        @tagger.tags.should_not be_include("two")
-    end
-
-    it "should add all provided tags to the tag list" do
-        @tagger.tag("one", "two")
-        @tagger.tags.should be_include("one")
-        @tagger.tags.should be_include("two")
-    end
-
-    it "should fail on tags containing '*' characters" do
-        lambda { @tagger.tag("bad*tag") }.should raise_error(Puppet::ParseError)
-    end
-
-    it "should fail on tags starting with '-' characters" do
-        lambda { @tagger.tag("-badtag") }.should raise_error(Puppet::ParseError)
-    end
-
-    it "should fail on tags containing ' ' characters" do
-        lambda { @tagger.tag("bad tag") }.should raise_error(Puppet::ParseError)
-    end
-
-    it "should allow alpha tags" do
-        lambda { @tagger.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
-    end
-
-    it "should allow tags containing '.' characters" do
-        lambda { @tagger.tag("good.tag") }.should_not raise_error(Puppet::ParseError)
-    end
-
-    it "should provide a method for testing tag validity" do
-        @tagger.metaclass.publicize_methods(:valid_tag?)  { @tagger.should be_respond_to(:valid_tag?) }
-    end
-
-    it "should add qualified classes as tags" do
-        @tagger.tag("one::two")
-        @tagger.tags.should be_include("one::two")
-    end
-
-    it "should add each part of qualified classes as tags" do
-        @tagger.tag("one::two::three")
-        @tagger.tags.should be_include("one")
-        @tagger.tags.should be_include("two")
-        @tagger.tags.should be_include("three")
-    end
-
-    it "should indicate when the object is tagged with a provided tag" do
-        @tagger.tag("one")
-        @tagger.should be_tagged("one")
-    end
-
-    it "should indicate when the object is not tagged with a provided tag" do
-        @tagger.should_not be_tagged("one")
-    end
-
-    it "should indicate when the object is tagged with any tag in an array" do
-        @tagger.tag("one")
-        @tagger.should be_tagged("one","two","three")
-    end
-
-    it "should indicate when the object is not tagged with any tag in an array" do
-        @tagger.tag("one")
-        @tagger.should_not be_tagged("two","three")
-    end
-end

data/spec/unit/util/user_attr.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/util/user_attr'
-
-describe UserAttr do
-    before do
-        user_attr = ["foo::::type=role", "bar::::type=normal;profile=foobar"]
-        File.stubs(:readlines).returns(user_attr)
-    end
-
-    describe "when getting attributes by name" do
-        it "should return nil if there is no entry for that name" do
-            UserAttr.get_attributes_by_name('baz').should == nil
-        end
-
-        it "should return a hash if there is an entry in /etc/user_attr" do
-            UserAttr.get_attributes_by_name('foo').class.should == Hash
-        end
-
-        it "should return a hash with the name value from /etc/user_attr" do
-             UserAttr.get_attributes_by_name('foo')[:name].should == 'foo'
-        end
-
-        #this test is contrived
-        #there are a bunch of possible parameters that could be in the hash
-        #the role/normal is just a the convention of the file
-        describe "when the name is a role" do
-            it "should contain :type = role" do
-                UserAttr.get_attributes_by_name('foo')[:type].should == 'role'
-            end
-        end
-
-        describe "when the name is not a role" do
-            it "should contain :type = normal" do
-                UserAttr.get_attributes_by_name('bar')[:type].should == 'normal'
-            end
-        end
-
-        describe "when the name has more attributes" do
-            it "should contain all the attributes" do
-                UserAttr.get_attributes_by_name('bar')[:profile].should == 'foobar'
-            end
-        end
-    end
-end

data/spec/unit/util/warnings.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Puppet::Util::Warnings do
-    before(:all) do
-        @msg1 = "booness"
-        @msg2 = "more booness"
-    end
-
-    {:notice => "notice_once", :warning => "warnonce"}.each do |log, method|
-        describe "when registring '%s' messages" % log do
-            it "should always return nil" do
-                Puppet::Util::Warnings.send(method, @msg1).should be(nil)
-            end
-
-            it "should issue a warning" do
-                Puppet.expects(log).with(@msg1)
-                Puppet::Util::Warnings.send(method, @msg1)
-            end
-
-            it "should issue a warning exactly once per unique message" do
-                Puppet.expects(log).with(@msg1).once
-                Puppet::Util::Warnings.send(method, @msg1)
-                Puppet::Util::Warnings.send(method, @msg1)
-            end
-
-            it "should issue multiple warnings for multiple unique messages" do
-                Puppet.expects(log).times(2)
-                Puppet::Util::Warnings.send(method, @msg1)
-                Puppet::Util::Warnings.send(method, @msg2)
-            end
-        end
-    end
-
-    after(:each) do
-        Puppet::Util::Warnings.clear_warnings()
-    end
-end

data/spec/unit/util/zaml.rb

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-require 'puppet/util/monkey_patches'
-
-describe "Pure ruby yaml implementation" do
-    {
-    7            => "--- 7",
-    3.14159      => "--- 3.14159",
-    'test'       => "--- test",
-    []           => "--- []",
-    :symbol      => "--- !ruby/sym symbol",
-    {:a => "A"}  => "--- \n  !ruby/sym a: A"
-    }.each { |o,y| 
-        it "should convert the #{o.class} #{o.inspect} to yaml" do
-            o.to_yaml.should == y
-        end
-        it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
-            YAML.load(o.to_yaml).should == o
-        end
-    }
-    #
-    # Can't test for equality on raw objects
-    {
-    Object.new                   => "--- !ruby/object {}",
-    [Object.new]                 => "--- \n  - !ruby/object {}",
-    {Object.new => Object.new}   => "--- \n  ? !ruby/object {}\n  : !ruby/object {}"
-    }.each { |o,y| 
-        it "should convert the #{o.class} #{o.inspect} to yaml" do
-            o.to_yaml.should == y
-        end
-        it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
-            lambda { YAML.load(o.to_yaml) }.should_not raise_error
-        end
-    }
-end
-

data/test/language/ast/casestatement.rb

@@ -1,103 +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 TestCaseStatement < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    AST = Puppet::Parser::AST
-
-    class ActiveAST < FakeAST
-        def self.clear
-            $evaluated = []
-        end
-        def evaluate
-            $evaluated ||= []
-            $evaluated << @evaluate
-        end
-    end
-
-    def test_evaluate
-        ast = nil
-        scope = mkscope
-        param = nameobj("MyParam")
-
-        hash = {
-            "myparam" => ActiveAST.new("lower"),
-            "MyParam" => ActiveAST.new("upper"),
-            true => ActiveAST.new(true)
-        }
-        options = ["myparam", "MyParam"].collect do |p|
-            AST::CaseOpt.new(:value => FakeAST.new(p), :statements => hash[p])
-        end
-        assert_nothing_raised do
-            ast = AST::CaseStatement.new(:test => param, :options => options)
-        end
-
-        # Start out case-sensitive
-        Puppet[:casesensitive] = true
-
-        result = nil
-        assert_nothing_raised do
-            result = ast.evaluate scope
-        end
-        assert(result, "did not get valid result")
-        assert_equal(["upper"], $evaluated, "Did not match case-sensitively")
-        assert(! hash["myparam"].evaluated?, "lower value was evaluated even though it did not match")
-
-        # Now try it case-insensitive
-        Puppet[:casesensitive] = false
-        $evaluated.clear
-        hash["MyParam"].reset
-        assert_nothing_raised do
-            result = ast.evaluate scope
-        end
-        assert(result, "did not get valid result")
-        assert_equal(["lower"], result, "Did not match case-insensitively")
-        assert(! hash["MyParam"].evaluated?, "upper value was evaluated even though it did not match")
-    end
-
-    # #522 - test that case statements with multiple values work as
-    # expected, where any true value suffices.
-    def test_multiple_values
-        ast = nil
-
-        tests = {
-            "one" => %w{a b c},
-            "two" => %w{e f g}
-        }
-        options = tests.collect do |result, values|
-            values = values.collect { |v| AST::Leaf.new :value => v }
-            AST::CaseOpt.new(:value => AST::ASTArray.new(:children => values),
-                :statements => AST::Leaf.new(:value => result))
-        end
-        options << AST::CaseOpt.new(:value => AST::Default.new(:value => "default"),
-            :statements => AST::Leaf.new(:value => "default"))
-
-        ast = nil
-        param = AST::Variable.new(:value => "testparam")
-        assert_nothing_raised do
-            ast = AST::CaseStatement.new(:test => param, :options => options)
-        end
-        result = nil
-        tests.each do |should, values|
-            values.each do |value|
-                result = nil
-                scope = mkscope
-                scope.setvar("testparam", value)
-                assert_nothing_raised do
-                    result = ast.evaluate(scope)
-                end
-
-                assert_equal(should, result, "Got incorrect result for %s" % value)
-            end
-        end
-    end
-end
-

data/test/language/ast/resource.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2007-07-8.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/parsertesting'
-
-class TestASTResource< Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    AST = Puppet::Parser::AST
-
-    def setup
-        super
-        @scope = mkscope
-        @parser = @scope.compiler.parser
-    end
-
-    def newdef(type, title, params = nil)
-        params ||= AST::ASTArray.new(:children => [])
-        AST::Resource.new(:type => type, :title => AST::String.new(:value => title), :params => params)
-    end
-
-    # Related to #806, make sure resources always look up the full path to the resource.
-    def test_scoped_types
-        @parser.newdefine "one"
-        @parser.newdefine "one::two"
-        @parser.newdefine "three"
-        twoscope = @scope.newscope(:namespace => "one")
-        twoscope.resource = @scope.resource
-        assert(twoscope.find_definition("two"), "Could not find 'two' definition")
-        title = "title"
-
-        # First try a qualified type
-        assert_equal("One::Two", newdef("two", title).evaluate(twoscope)[0].type,
-            "Defined type was not made fully qualified")
-
-        # Then try a type that does not need to be qualified
-        assert_equal("One", newdef("one", title).evaluate(twoscope)[0].type,
-            "Unqualified defined type was not handled correctly")
-
-        # Then an unqualified type from within the one namespace
-        assert_equal("Three", newdef("three", title).evaluate(twoscope)[0].type,
-            "Defined type was not made fully qualified")
-
-        # Then a builtin type
-        assert_equal("File", newdef("file", title).evaluate(twoscope)[0].type,
-            "Builtin type was not handled correctly")
-
-        # Now try a type that does not exist, which should throw an error.
-        assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newdef("nosuchtype", title).evaluate(twoscope)
-        end
-    end
-end

data/test/language/ast/resource_reference.rb

@@ -1,77 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2007-07-8.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/parsertesting'
-
-class TestASTResourceReference < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::ParserTesting
-    AST = Puppet::Parser::AST
-
-    def newref(type, title)
-        AST::ResourceReference.new(:type => type, :title => AST::String.new(:value => title))
-    end
-
-    def setup
-        super
-        @scope = mkscope
-        @parser = @scope.compiler.parser
-    end
-
-    # Related to #706, make sure resource references correctly translate to qualified types.
-    def test_scoped_references
-        @parser.newdefine "one"
-        @parser.newdefine "one::two"
-        @parser.newdefine "three"
-        twoscope = @scope.newscope(:namespace => "one")
-        assert(twoscope.find_definition("two"), "Could not find 'two' definition")
-        title = "title"
-
-        # First try a qualified type
-        assert_equal("One::Two", newref("two", title).evaluate(twoscope).type,
-            "Defined type was not made fully qualified")
-
-        # Then try a type that does not need to be qualified
-        assert_equal("One", newref("one", title).evaluate(twoscope).type,
-            "Unqualified defined type was not handled correctly")
-
-        # Then an unqualified type from within the one namespace
-        assert_equal("Three", newref("three", title).evaluate(twoscope).type,
-            "Defined type was not made fully qualified")
-
-        # Then a builtin type
-        assert_equal("File", newref("file", title).evaluate(twoscope).type,
-            "Builtin type was not handled correctly")
-
-        # Now try a type that does not exist, which should throw an error.
-        assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newref("nosuchtype", title).evaluate(twoscope)
-        end
-
-        # Now run the same tests, but with the classes
-        @parser.newclass "four"
-        @parser.newclass "one::five"
-
-        # First try an unqualified type
-        assert_equal("four", newref("class", "four").evaluate(twoscope).title,
-            "Unqualified class was not found")
-
-        # Then a qualified class
-        assert_equal("one::five", newref("class", "five").evaluate(twoscope).title,
-            "Class was not made fully qualified")
-
-        # Then try a type that does not need to be qualified
-        assert_equal("four", newref("class", "four").evaluate(twoscope).title,
-            "Unqualified class was not handled correctly")
-
-        # Now try a type that does not exist, which should throw an error.
-        assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
-            newref("class", "nosuchclass").evaluate(twoscope)
-        end
-    end
-end