puppet 2.6.18 → 2.7.1

data/test/data/providers/host/parsed/valid_hosts

@@ -0,0 +1,19 @@
+# Some leading comment, that should be ignored
+# The next line is empty so it should be ignored
+
+::1 localhost
+
+# We now try another delimiter: Several tabs
+127.0.0.1         localhost
+
+# No test trailing spaces
+10.0.0.1         host1         
+
+# Ok its time to test aliases
+2001:252:0:1::2008:8 ipv6host alias1
+192.168.0.1 ipv4host alias2 alias3
+
+# Testing inlinecomments now
+192.168.0.2 host3 # This is host3
+192.168.0.3 host4 alias10 # This is host4
+192.168.0.4 host5   alias11             alias12      #     This is host5

data/test/language/ast.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'puppettest'
 require 'puppet/parser/parser'

data/test/language/ast/variable.rb

@@ -3,7 +3,7 @@
 #  Created by Luke A. Kanies on 2007-0419.
 #  Copyright (c) 2006. All rights reserved.
 
-require File.dirname(__FILE__) + '/../../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
 
 require 'puppettest'
 require 'puppettest/parsertesting'

data/test/language/functions.rb

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'puppet'
 require 'puppet/parser/parser'
+require 'puppet/network/client'
 require 'puppettest'
 require 'puppettest/resourcetesting'
 
@@ -381,17 +382,15 @@ class TestLangFunctions < Test::Unit::TestCase
     }.each do |string, value|
       scope = mkscope
       scope.setvar("yayness", string)
-      assert_equal(string, scope.lookupvar("yayness", false))
+      assert_equal(string, scope.lookupvar("yayness"))
 
       assert_nothing_raised("An empty string was not a valid variable value") do
         ast.evaluate(scope)
       end
 
-
-        assert_equal(
-          "template #{value}\n", scope.lookupvar("output"),
-
-            "#{string.inspect} did not get evaluated correctly")
+      assert_equal(
+        "template #{value}\n", scope.lookupvar("output"),
+        "#{string.inspect} did not get evaluated correctly")
     end
   end
 
@@ -446,11 +445,11 @@ class TestLangFunctions < Test::Unit::TestCase
 
     include = Puppet::Parser::Functions.function(:include)
 
-    assert_raise(Puppet::ParseError, "did not throw error on missing class") do
+    assert_raise(Puppet::Error, "did not throw error on missing class") do
       scope.function_include("nosuchclass")
     end
 
-    parser.newclass("myclass")
+    scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "myclass", {})
 
     scope.compiler.expects(:evaluate_classes).with(%w{myclass otherclass}, scope, false).returns(%w{myclass otherclass})
 

data/test/language/parser.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'mocha'
 require 'puppet'
@@ -14,7 +14,6 @@ class TestParser < Test::Unit::TestCase
   include PuppetTest::Support::Utils
   def setup
     super
-    Puppet[:parseonly] = true
     #@lexer = Puppet::Parser::Lexer.new
   end
 
@@ -39,9 +38,8 @@ class TestParser < Test::Unit::TestCase
     failers { |file|
       parser = mkparser
       Puppet.debug("parsing failer #{file}") if __FILE__ == $0
-      assert_raise(Puppet::ParseError, "Did not fail while parsing #{file}") {
-        parser.file = file
-        ast = parser.parse
+      assert_raise(Puppet::ParseError, Puppet::Error, "Did not fail while parsing #{file}") {
+        Puppet[:manifest] = file
         config = mkcompiler(parser)
         config.compile
         #ast.hostclass("").evaluate config.topscope
@@ -288,7 +286,7 @@ class TestParser < Test::Unit::TestCase
       ret = parser.parse
     }
 
-    ret.hostclass("").code.each do |obj|
+    ret.code.each do |obj|
       assert_instance_of(AST::Collection, obj)
     end
   end
@@ -362,12 +360,12 @@ file { "/tmp/yayness":
 
 
     assert_raise(Puppet::ParseError) {
-      parser.parse %{define mydef($schedule) {}}
+      parser.known_resource_types.import_ast(parser.parse(%{define mydef($schedule) {}}), '')
     }
 
     assert_nothing_raised {
-      parser.parse %{define adef($schedule = false) {}}
-      parser.parse %{define mydef($schedule = daily) {}}
+      parser.known_resource_types.import_ast(parser.parse(%{define adef($schedule = false) {}}), '')
+      parser.known_resource_types.import_ast(parser.parse(%{define mydef($schedule = daily) {}}), '')
     }
   end
 
@@ -379,12 +377,12 @@ file { "/tmp/yayness":
     str1 = %{if true { #{exec.call("true")} }}
     ret = nil
     assert_nothing_raised {
-      ret = parser.parse(str1).hostclass("").code[0]
+      ret = parser.parse(str1).code[0]
     }
     assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
     parser = mkparser
     str2 = %{if true { #{exec.call("true")} } else { #{exec.call("false")} }}
-    ret = parser.parse(str2).hostclass("").code[0]
+    ret = parser.parse(str2).code[0]
     assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
     assert_instance_of(Puppet::Parser::AST::Else, ret.else)
   end
@@ -393,23 +391,23 @@ file { "/tmp/yayness":
     parser = mkparser
 
     assert_nothing_raised {
-      parser.parse %{class myclass { class other {} }}
+      parser.known_resource_types.import_ast(parser.parse(%{class myclass { class other {} }}), '')
     }
     assert(parser.hostclass("myclass"), "Could not find myclass")
     assert(parser.hostclass("myclass::other"), "Could not find myclass::other")
 
     assert_nothing_raised {
-      parser.parse "class base {}
+      parser.known_resource_types.import_ast(parser.parse("class base {}
       class container {
         class deep::sub inherits base {}
-      }"
+      }"), '')
     }
     sub = parser.hostclass("container::deep::sub")
     assert(sub, "Could not find sub")
 
     # Now try it with a parent class being a fq class
     assert_nothing_raised {
-      parser.parse "class container::one inherits container::deep::sub {}"
+      parser.known_resource_types.import_ast(parser.parse("class container::one inherits container::deep::sub {}"), '')
     }
     sub = parser.hostclass("container::one")
     assert(sub, "Could not find one")
@@ -417,7 +415,7 @@ file { "/tmp/yayness":
 
     # Finally, try including a qualified class
     assert_nothing_raised("Could not include fully qualified class") {
-      parser.parse "include container::deep::sub"
+      parser.known_resource_types.import_ast(parser.parse("include container::deep::sub"), '')
     }
   end
 
@@ -426,20 +424,11 @@ file { "/tmp/yayness":
 
     # Make sure we put the top-level code into a class called "" in
     # the "" namespace
-    assert_nothing_raised do
-      out = parser.parse ""
-
-      assert_instance_of(Puppet::Resource::TypeCollection, out)
-      assert_nil(parser.hostclass(""), "Got a 'main' class when we had no code")
-    end
-
-    # Now try something a touch more complicated
     parser.initvars
     assert_nothing_raised do
-      out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
-      assert_instance_of(Puppet::Resource::TypeCollection, out)
-      assert_equal("", parser.hostclass("").name)
-      assert_equal("", parser.hostclass("").namespace)
+      parser.known_resource_types.import_ast(parser.parse("Exec { path => '/usr/bin:/usr/sbin' }"), '')
+      assert_equal("", parser.known_resource_types.hostclass("").name)
+      assert_equal("", parser.known_resource_types.hostclass("").namespace)
     end
   end
 
@@ -482,22 +471,26 @@ file { "/tmp/yayness":
 
       ret = nil
       assert_nothing_raised do
-        ret = parser.parse("#{at}file { '/tmp/testing': owner => root }")
+        parser.known_resource_types.import_ast(parser.parse("#{at}file { '/tmp/testing': owner => root }"), '')
+        ret = parser.known_resource_types
       end
 
       assert_instance_of(AST::ASTArray, ret.hostclass("").code)
       resdef = ret.hostclass("").code[0]
       assert_instance_of(AST::Resource, resdef)
-      assert_equal("/tmp/testing", resdef.title.value)
+      assert_instance_of(AST::ASTArray, resdef.instances)
+      assert_equal(1, resdef.instances.children.length)
+      assert_equal("/tmp/testing", resdef.instances[0].title.value)
       # We always get an astarray back, so...
       check.call(resdef, "simple resource")
 
       # Now let's try it with multiple resources in the same spec
       assert_nothing_raised do
-        ret = parser.parse("#{at}file { ['/tmp/1', '/tmp/2']: owner => root }")
+        parser.known_resource_types.import_ast(parser.parse("#{at}file { ['/tmp/1', '/tmp/2']: owner => root }"), '')
+        ret = parser.known_resource_types
       end
 
-      ret.hostclass("").code.each do |res|
+      ret.hostclass("").code[0].each do |res|
         assert_instance_of(AST::Resource, res)
         check.call(res, "multiresource")
       end
@@ -506,9 +499,9 @@ file { "/tmp/yayness":
   ensure
     if Puppet.features.rails?
       Puppet[:storeconfigs] = false
-      Puppet::Resource::Catalog.cache_class =  catalog_cache_class
-      Puppet::Node::Facts.cache_class = facts_cache_class
-      Puppet::Node.cache_class = node_cache_class
+      Puppet::Resource::Catalog.indirection.cache_class =  catalog_cache_class
+      Puppet::Node::Facts.indirection.cache_class = facts_cache_class
+      Puppet::Node.indirection.cache_class = node_cache_class
     end
   end
 
@@ -537,7 +530,7 @@ file { "/tmp/yayness":
         ret = parser.parse("File #{arrow}")
       end
 
-      coll = ret.hostclass("").code[0]
+      coll = ret.code[0]
       assert_instance_of(AST::Collection, coll)
       assert_equal(form, coll.form)
     end
@@ -545,9 +538,9 @@ file { "/tmp/yayness":
   ensure
     if Puppet.features.rails?
       Puppet[:storeconfigs] = false
-      Puppet::Resource::Catalog.cache_class =  catalog_cache_class
-      Puppet::Node::Facts.cache_class = facts_cache_class
-      Puppet::Node.cache_class = node_cache_class
+      Puppet::Resource::Catalog.indirection.cache_class =  catalog_cache_class
+      Puppet::Node::Facts.indirection.cache_class = facts_cache_class
+      Puppet::Node.indirection.cache_class = node_cache_class
     end
   end
 
@@ -560,7 +553,7 @@ file { "/tmp/yayness":
 
       res = nil
       assert_nothing_raised do
-        res = parser.parse(str).hostclass("").code[0]
+        res = parser.parse(str).code[0]
       end
 
       assert_instance_of(AST::Collection, res)
@@ -583,7 +576,7 @@ file { "/tmp/yayness":
 
       res = nil
       assert_nothing_raised do
-        res = parser.parse(str).hostclass("").code[0]
+        res = parser.parse(str).code[0]
       end
 
       assert_instance_of(AST::Collection, res)
@@ -607,7 +600,7 @@ file { "/tmp/yayness":
 
       res = nil
       assert_nothing_raised("Could not parse '#{test}'") do
-        res = parser.parse(str).hostclass("").code[0]
+        res = parser.parse(str).code[0]
       end
 
       assert_instance_of(AST::Collection, res)
@@ -624,15 +617,11 @@ file { "/tmp/yayness":
   def test_fully_qualified_definitions
     parser = mkparser
 
+    types = parser.known_resource_types
     assert_nothing_raised("Could not parse fully-qualified definition") {
-      parser.parse %{define one::two { }}
+      types.import_ast(parser.parse(%{define one::two { }}), '')
     }
     assert(parser.definition("one::two"), "Could not find one::two with no namespace")
-
-    # Now try using the definition
-    assert_nothing_raised("Could not parse fully-qualified definition usage") {
-      parser.parse %{one::two { yayness: }}
-    }
   end
 
   # #524
@@ -691,7 +680,7 @@ file { "/tmp/yayness":
       result = parser.parse %{$variable = undef}
     }
 
-    main = result.hostclass("").code
+    main = result.code
     children = main.children
     assert_instance_of(AST::VarDef, main.children[0])
     assert_instance_of(AST::Undef, main.children[0].value)
@@ -704,7 +693,8 @@ file { "/tmp/yayness":
     str = "file { '/tmp/yay': ensure => file }\nclass yay {}\nnode foo {}\ndefine bar {}\n"
     result = nil
     assert_nothing_raised("Could not parse") do
-      result = parser.parse(str)
+      parser.known_resource_types.import_ast(parser.parse(str), '')
+      result = parser.known_resource_types
     end
     assert_instance_of(Puppet::Resource::TypeCollection, result, "Did not get a ASTSet back from parsing")
 
@@ -734,12 +724,14 @@ file { "/tmp/yayness":
 
     result = nil
     assert_nothing_raised do
-      result = parser.newclass "Yayness"
+      parser.known_resource_types.import_ast(parser.parse("class yayness { }"), '')
+      result = parser.known_resource_types.hostclass('yayness')
     end
     assert_equal(result, parser.find_hostclass("", "yayNess"))
 
     assert_nothing_raised do
-      result = parser.newdefine "FunTest"
+      parser.known_resource_types.import_ast(parser.parse("define funtest { }"), '')
+      result = parser.known_resource_types.definition('funtest')
     end
     assert_equal(result, parser.find_definition("", "fUntEst"), "#{"fUntEst"} was not matched")
   end

data/test/language/scope.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'mocha'
 require 'puppettest'
@@ -42,22 +42,22 @@ class TestScope < Test::Unit::TestCase
     # Set a variable in the top and make sure all three can get it
     topscope.setvar("first", "topval")
     scopes.each do |name, scope|
-      assert_equal("topval", scope.lookupvar("first", false), "Could not find var in #{name}")
+      assert_equal("topval", scope.lookupvar("first"), "Could not find var in #{name}")
     end
 
     # Now set a var in the midscope and make sure the mid and bottom can see it but not the top
     midscope.setvar("second", "midval")
-    assert_equal(:undefined, scopes[:top].lookupvar("second", false), "Found child var in top scope")
+    assert_equal(:undefined, scopes[:top].lookupvar("second"), "Found child var in top scope")
     [:mid, :bot].each do |name|
-      assert_equal("midval", scopes[name].lookupvar("second", false), "Could not find var in #{name}")
+      assert_equal("midval", scopes[name].lookupvar("second"), "Could not find var in #{name}")
     end
 
     # And set something in the bottom, and make sure we only find it there.
     botscope.setvar("third", "botval")
     [:top, :mid].each do |name|
-      assert_equal(:undefined, scopes[name].lookupvar("third", false), "Found child var in top scope")
+      assert_equal(:undefined, scopes[name].lookupvar("third"), "Found child var in top scope")
     end
-    assert_equal("botval", scopes[:bot].lookupvar("third", false), "Could not find var in bottom scope")
+    assert_equal("botval", scopes[:bot].lookupvar("third"), "Could not find var in bottom scope")
 
 
     # Test that the scopes convert to hash structures correctly.
@@ -163,7 +163,7 @@ class TestScope < Test::Unit::TestCase
     config = mkcompiler
 
     # Create a default source
-    parser.newclass("")
+    parser.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
     config.topscope.source = parser.known_resource_types.hostclass("")
 
     # And a scope resource
@@ -175,12 +175,12 @@ class TestScope < Test::Unit::TestCase
     )
 
     # Create a top-level define
-    parser.newdefine "one", :arguments => [%w{arg}],
+    parser.known_resource_types.add Puppet::Resource::Type.new(:definition, "one", :arguments => [%w{arg}],
       :code => AST::ASTArray.new(
         :children => [
           resourcedef("file", "/tmp", {"owner" => varref("arg")})
         ]
-      )
+      ))
 
     # create a resource that calls our third define
     obj = resourcedef("one", "boo", {"arg" => "parentfoo"})
@@ -233,9 +233,9 @@ Host <<||>>"
     }
   ensure
     Puppet[:storeconfigs] = false
-    Puppet::Resource::Catalog.cache_class =  catalog_cache_class
-    Puppet::Node::Facts.cache_class = facts_cache_class
-    Puppet::Node.cache_class = node_cache_class
+    Puppet::Resource::Catalog.indirection.cache_class =  catalog_cache_class
+    Puppet::Node::Facts.indirection.cache_class = facts_cache_class
+    Puppet::Node.indirection.cache_class = node_cache_class
   end
   else
     $stderr.puts "No ActiveRecord -- skipping collection tests"
@@ -260,18 +260,7 @@ Host <<||>>"
     scope = mkscope
 
     scope.setvar("testing", :undef)
-
-
-      assert_equal(
-        :undef, scope.lookupvar("testing", false),
-
-      "undef was not returned as :undef when not string")
-
-
-        assert_equal(
-          "", scope.lookupvar("testing", true),
-
-      "undef was not returned as '' when string")
+    assert_equal(:undef, scope.lookupvar("testing"), "undef was not returned as :undef")
   end
 end
 

data/test/language/snippets.rb

@@ -1,9 +1,11 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/puppettest'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
 
 require 'puppet'
 require 'puppet/parser/parser'
+require 'puppet/network/client'
+require 'puppet/network/handler'
 require 'puppettest'
 
 class TestSnippets < Test::Unit::TestCase
@@ -67,6 +69,13 @@ class TestSnippets < Test::Unit::TestCase
     ast
   end
 
+  def client
+    args = {
+      :Listen => false
+    }
+    Puppet::Network::Client.new(args)
+  end
+
   def ast2scope(ast)
     scope = Puppet::Parser::Scope.new
     ast.evaluate(scope)
@@ -495,7 +504,7 @@ class TestSnippets < Test::Unit::TestCase
 
         catalog = nil
         assert_nothing_raised("Could not compile catalog") {
-          catalog = Puppet::Resource::Catalog.find(node.name)
+          catalog = Puppet::Resource::Catalog.indirection.find(node)
         }
 
         assert_nothing_raised("Could not convert catalog") {