puppet 0.24.1 → 0.24.2

data/test/language/lexer.rb

@@ -1,276 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/parser/lexer'
-require 'puppettest'
-
-#%q{service("telnet") = \{
-#    port => "23",
-#    protocol => "tcp",
-#    name => "telnet",
-#\}
-#} => [[:NAME, "service"], [:LPAREN, "("], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:RPAREN, ")"], [:EQUALS, "="], [:lbrace, "{"], [:NAME, "port"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "23"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "protocol"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "tcp"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "name"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:COMMA, ","], [:RBRACE, "}"]]
-
-class TestLexer < Test::Unit::TestCase
-	include PuppetTest
-    def setup
-        super
-        mklexer
-    end
-
-    def mklexer
-        @lexer = Puppet::Parser::Lexer.new()
-    end
-
-    def test_simple_lex
-        strings = {
-%q{\\} => [[:BACKSLASH,"\\"],[false,false]],
-%q{simplest scanner test} => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"],[false,false]],
-%q{returned scanner test
-} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"],[false,false]]
-        }
-        strings.each { |str,ary|
-            @lexer.string = str
-            assert_equal(
-                ary,
-                @lexer.fullscan()
-            )
-        }
-    end
-
-    def test_quoted_strings
-        strings = {
-%q{a simple "scanner" test
-} => [[:NAME,"a"],[:NAME,"simple"],[:DQTEXT,"scanner"],[:NAME,"test"],[false,false]],
-%q{a simple 'single quote scanner' test
-} => [[:NAME,"a"],[:NAME,"simple"],[:SQTEXT,"single quote scanner"],[:NAME,"test"],[false,false]],
-%q{a harder 'a $b \c"'
-} => [[:NAME,"a"],[:NAME,"harder"],[:SQTEXT,'a $b \c"'],[false,false]],
-%q{a harder "scanner test"
-} => [[:NAME,"a"],[:NAME,"harder"],[:DQTEXT,"scanner test"],[false,false]],
-%q{a hardest "scanner \"test\""
-} => [[:NAME,"a"],[:NAME,"hardest"],[:DQTEXT,'scanner "test"'],[false,false]],
-%q{a hardestest "scanner \"test\"
-"
-} => [[:NAME,"a"],[:NAME,"hardestest"],[:DQTEXT,'scanner "test"
-'],[false,false]],
-%q{function("call")} => [[:NAME,"function"],[:LPAREN,"("],[:DQTEXT,'call'],[:RPAREN,")"],[false,false]]
-}
-        strings.each { |str,array|
-            @lexer.string = str
-            assert_equal(
-                array,
-                @lexer.fullscan()
-            )
-        }
-    end
-
-    def test_errors
-        strings = %w{
-            ^
-        }
-        strings.each { |str|
-            @lexer.string = str
-            assert_raise(RuntimeError) {
-                @lexer.fullscan()
-            }
-        }
-    end
-
-    def test_more_error
-        assert_raise(TypeError) {
-            @lexer.fullscan()
-        }
-    end
-
-    def test_files
-        textfiles() { |file|
-            lexer = Puppet::Parser::Lexer.new()
-            lexer.file = file
-            assert_nothing_raised("Failed to lex %s" % file) {
-                lexer.fullscan()
-            }
-            Puppet::Type.allclear
-        }
-    end
-
-    def test_strings
-        names = %w{this is a bunch of names}
-        types = %w{Many Different Words A Word}
-        words = %w{differently Cased words A a}
-
-        names.each { |t|
-            @lexer.string = t
-            assert_equal(
-                [[:NAME,t],[false,false]],
-                @lexer.fullscan
-            )
-        }
-        types.each { |t|
-            @lexer.string = t
-            assert_equal(
-                [[:CLASSREF,t],[false,false]],
-                @lexer.fullscan
-            )
-        }
-    end
-
-    def test_emptystring
-        bit = '$var = ""'
-
-        assert_nothing_raised {
-            @lexer.string = bit
-        }
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-    end
-
-    def test_collectlexing
-        {"@" => :AT, "<|" => :LCOLLECT, "|>" => :RCOLLECT}.each do |string, token|
-            assert_nothing_raised {
-                @lexer.string = string
-            }
-
-            ret = nil
-            assert_nothing_raised {
-                ret = @lexer.fullscan
-            }
-
-            assert_equal([[token, string],[false, false]], ret)
-        end
-    end
-
-    def test_collectabletype
-        string = "@type {"
-
-        assert_nothing_raised {
-            @lexer.string = string
-        }
-
-        ret = nil
-        assert_nothing_raised {
-            ret = @lexer.fullscan
-        }
-
-        assert_equal([[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]],ret)
-    end
-
-    def test_namespace
-        @lexer.string = %{class myclass}
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("myclass", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("", @lexer.namespace)
-
-        @lexer.string = "class base { class sub { class more"
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("base::sub::more", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("base::sub", @lexer.namespace)
-
-        # Now try it with some fq names
-        mklexer
-
-        @lexer.string = "class base { class sub::more {"
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("base::sub::more", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("base", @lexer.namespace)
-    end
-
-    def test_indefine
-        @lexer.string = %{define me}
-
-        assert_nothing_raised {
-            @lexer.scan { |t,s| }
-        }
-
-        assert(@lexer.indefine?, "Lexer not considered in define")
-
-        # Now make sure we throw an error when trying to nest defines.
-        assert_raise(Puppet::ParseError) do
-            @lexer.string = %{define another}
-            @lexer.scan { |t,s| }
-        end
-
-        assert_nothing_raised do
-            @lexer.indefine = false
-        end
-
-        assert(! @lexer.indefine?, "Lexer still considered in define")
-    end
-
-    # Make sure the different qualified variables work.
-    def test_variable
-        ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
-            @lexer.string = string
-
-            assert_nothing_raised("Could not lex %s" % string) do
-                @lexer.scan do |t, s|
-                    assert_equal(:VARIABLE, t, "did not get variable as token")
-                    assert_equal(string.sub(/^\$/, ''), s, "did not get correct string back")
-                    break
-                end
-            end
-        end
-    end
-
-    # Make sure the expected stack works as it should
-    def test_expected
-        @lexer.string = "[a{"
-        expected = @lexer.instance_variable_get("@expected")
-        @lexer.scan {}
-        assert_equal("}", @lexer.expected, "expected value is wrong")
-
-        @lexer.string = "}"
-        @lexer.scan {}
-        assert_equal("]", @lexer.expected, "expected value is wrong after pop")
-    end
-
-    # #774
-    def test_classref_token
-        string = ["Foo", "::Foo","Foo::Bar","::Foo::Bar"]
-
-        string.each do |foo|
-            assert_nothing_raised {
-                @lexer.string = foo
-            }
-
-            ret = nil
-            assert_nothing_raised {
-                ret = @lexer.fullscan
-            }
-
-            assert_equal([:CLASSREF, foo],ret[0], "Did not correctly tokenize '%s'" % foo)
-        end
-    end
-end
-

data/test/lib/mocha.rb

@@ -1,19 +0,0 @@
-require 'mocha_standalone'
-require 'mocha/test_case_adapter'
-
-require 'test/unit/testcase'
-
-module Test
-
-  module Unit
-
-    class TestCase
-  
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      
-    end
-
-  end
-
-end

data/test/lib/mocha/any_instance_method.rb

@@ -1,35 +0,0 @@
-require 'mocha/class_method'
-
-module Mocha
-
-  class AnyInstanceMethod < ClassMethod
-  
-    def unstub
-      remove_new_method
-      restore_original_method
-      stubbee.any_instance.reset_mocha
-    end
-    
-    def mock
-      stubbee.any_instance.mocha
-    end
-   
-    def hide_original_method
-      stubbee.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.method_defined?(method)
-    end
-
-    def define_new_method
-      stubbee.class_eval "def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end"
-    end
-
-    def remove_new_method
-      stubbee.class_eval "remove_method :#{method}"
-    end
-
-    def restore_original_method
-      stubbee.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.method_defined?(hidden_method)
-    end
-
-  end
-  
-end

data/test/lib/mocha/auto_verify.rb

@@ -1,113 +0,0 @@
-require 'mocha/mock'
-
-module Mocha # :nodoc:
-  
-  # Methods added to TestCase allowing creation of traditional mock objects.
-  #
-  # Mocks created this way will have their expectations automatically verified at the end of the test.
-  #
-  # See Mock for methods on mock objects.
-  module AutoVerify
-  
-    def mocks # :nodoc:
-      @mocks ||= []
-    end
-  
-    def reset_mocks # :nodoc:
-      @mocks = nil
-    end
-    
-    # :call-seq: mock(name) -> mock object
-    #            mock(expected_methods = {}) -> mock object
-    #            mock(name, expected_methods = {}) -> mock object
-    #
-    # Creates a mock object.
-    #
-    # +name+ is a +String+ identifier for the mock object.
-    #
-    # +expected_methods+ is a +Hash+ with expected method name symbols as keys and corresponding return values as values.
-    #
-    # Note that (contrary to expectations set up by #stub) these expectations <b>must</b> be fulfilled during the test.
-    #   def test_product
-    #     product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
-    #   end 
-    def mock(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      build_mock_with_expectations(:expects, expectations, name)
-    end
-  
-    # :call-seq: stub(name) -> mock object
-    #            stub(stubbed_methods = {}) -> mock object
-    #            stub(name, stubbed_methods = {}) -> mock object
-    #
-    # Creates a mock object.
-    #
-    # +name+ is a +String+ identifier for the mock object.
-    #
-    # +stubbed_methods+ is a +Hash+ with stubbed method name symbols as keys and corresponding return values as values.
-    #
-    # Note that (contrary to expectations set up by #mock) these expectations <b>need not</b> be fulfilled during the test.
-    #   def test_product
-    #     product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
-    #     assert_equal 'ipod', product.manufacturer
-    #     assert_equal 100, product.price
-    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
-    #   end
-    def stub(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      build_mock_with_expectations(:stubs, expectations, name)
-    end
-  
-    # :call-seq: stub_everything(name) -> mock object
-    #            stub_everything(stubbed_methods = {}) -> mock object
-    #            stub_everything(name, stubbed_methods = {}) -> mock object
-    #
-    # Creates a mock object that accepts calls to any method.
-    #
-    # By default it will return +nil+ for any method call.
-    #
-    # +name+ and +stubbed_methods+ work in the same way as for #stub.
-    #   def test_product
-    #     product = stub_everything('ipod_product', :price => 100)
-    #     assert_nil product.manufacturer
-    #     assert_nil product.any_old_method
-    #     assert_equal 100, product.price
-    #   end
-    def stub_everything(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      build_mock_with_expectations(:stub_everything, expectations, name)
-    end
-    
-    def verify_mocks # :nodoc:
-      mocks.each { |mock| mock.verify { yield if block_given? } }
-    end
-
-    def teardown_mocks # :nodoc:
-      reset_mocks
-    end
-  
-    def build_mock_with_expectations(expectation_type = :expects, expectations = {}, name = nil) # :nodoc:
-      stub_everything = (expectation_type == :stub_everything)
-      expectation_type = :stubs if expectation_type == :stub_everything
-      mock = Mocha::Mock.new(stub_everything, name)
-      expectations.each do |method, result|
-        mock.__send__(expectation_type, method).returns(result)
-      end
-      mocks << mock
-      mock
-    end
-    
-  private
-
-    def name_and_expectations_from_args(args) # :nodoc:
-      name = args.first.is_a?(String) ? args.delete_at(0) : nil
-      expectations = args.first || {}
-      [name, expectations]
-    end
-  
-  end
-  
-end

data/test/lib/mocha/central.rb

@@ -1,35 +0,0 @@
-module Mocha
-  
-  class Central
-  
-    attr_accessor :stubba_methods
-  
-    def initialize
-      self.stubba_methods = []
-    end
-   
-    def stub(method)
-      unless stubba_methods.include?(method)
-        method.stub 
-        stubba_methods.push method
-      end
-    end
-    
-    def verify_all(&block)
-      unique_mocks.each { |mock| mock.verify(&block) }
-    end
-    
-    def unique_mocks
-      stubba_methods.inject({}) { |mocks, method| mocks[method.mock.__id__] = method.mock; mocks }.values
-    end
-  
-    def unstub_all
-      while stubba_methods.size > 0
-        method = stubba_methods.pop
-        method.unstub
-      end
-    end
-
-  end
-
-end