puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/node/facts_spec.rb

@@ -1,8 +1,17 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'matchers/json'
 require 'puppet/node/facts'
 
+# the json-schema gem doesn't support windows
+if not Puppet.features.microsoft_windows?
+  describe "catalog facts schema" do
+    it "should validate against the json meta-schema" do
+      JSON::Validator.validate!(JSON_META_SCHEMA, FACTS_SCHEMA)
+    end
+  end
+
+end
+
 describe Puppet::Node::Facts, "when indirecting" do
   before do
     @facts = Puppet::Node::Facts.new("me")
@@ -143,8 +152,16 @@ describe Puppet::Node::Facts, "when indirecting" do
         result = PSON.parse(facts.to_pson)
         result['name'].should == facts.name
         result['values'].should == facts.values.reject { |key, value| key.to_s =~ /_/ }
-        result['timestamp'].should == facts.timestamp.to_s
-        result['expiration'].should == facts.expiration.to_s
+        result['timestamp'].should == facts.timestamp.iso8601(9)
+        result['expiration'].should == facts.expiration.iso8601(9)
+      end
+
+      it "should generate valid facts data against the facts schema", :unless => Puppet.features.microsoft_windows? do
+        Time.stubs(:now).returns(@timestamp)
+        facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
+        facts.expiration = @expiration
+
+        JSON::Validator.validate!(FACTS_SCHEMA, facts.to_pson)
       end
 
       it "should not include nil values" do

data/spec/unit/node_spec.rb

@@ -2,6 +2,17 @@
 require 'spec_helper'
 require 'matchers/json'
 
+# the json-schema gem doesn't support windows
+if not Puppet.features.microsoft_windows?
+  NODE_SCHEMA = JSON.parse(File.read(File.join(File.dirname(__FILE__), '../../api/schemas/node.json')))
+
+  describe "node schema" do
+    it "should validate against the json meta-schema" do
+      JSON::Validator.validate!(JSON_META_SCHEMA, NODE_SCHEMA)
+    end
+  end
+end
+
 describe Puppet::Node do
   it "should register its document type as Node" do
     PSON.registered_document_types["Node"].should equal(Puppet::Node)
@@ -55,6 +66,38 @@ describe Puppet::Node do
     new_node.name.should == node.name
   end
 
+  it "can round-trip through pson" do
+    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+    node = Puppet::Node.new("hello",
+                            :environment => 'kjhgrg',
+                            :classes => ['erth', 'aiu'],
+                            :parameters => {"hostname"=>"food"}
+                           )
+    new_node = Puppet::Node.convert_from('pson', node.render('pson'))
+    new_node.environment.should == node.environment
+    new_node.parameters.should == node.parameters
+    new_node.classes.should == node.classes
+    new_node.name.should == node.name
+  end
+
+  it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+    node = Puppet::Node.new("hello",
+                            :environment => 'kjhgrg',
+                            :classes => ['erth', 'aiu'],
+                            :parameters => {"hostname"=>"food"}
+                           )
+    JSON::Validator.validate!(NODE_SCHEMA, node.to_pson)
+  end
+
+  it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+    node = Puppet::Node.new("hello",
+                            :environment => 'kjhgrg'
+                           )
+    JSON::Validator.validate!(NODE_SCHEMA, node.to_pson)
+  end
+
   describe "when converting to json" do
     before do
       @node = Puppet::Node.new("mynode")

data/spec/unit/parameter/boolean_spec.rb

@@ -5,21 +5,31 @@ require 'puppet/parameter/boolean'
 
 describe Puppet::Parameter::Boolean do
   let (:resource) { mock('resource') }
-  subject { described_class.new(:resource => resource) }
-
-  [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|
-    it "should munge #{arg.inspect} as true" do
-      subject.munge(arg).should == true
+  describe "after initvars" do
+    before { described_class.initvars }
+    it "should have the correct value_collection" do
+      described_class.value_collection.values.sort.should ==
+          [:true, :false, :yes, :no].sort
     end
   end
-  [ false, :false, 'false', :no, 'no', 'FaLSE', 'nO' ].each do |arg|
-    it "should munge #{arg.inspect} as false" do
-      subject.munge(arg).should == false
+
+  describe "instances" do
+    subject { described_class.new(:resource => resource) }
+
+    [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|
+      it "should munge #{arg.inspect} as true" do
+        subject.munge(arg).should == true
+      end
     end
-  end
-  [ nil, :undef, 'undef', '0', 0, '1', 1, 9284 ].each do |arg|
-    it "should fail to munge #{arg.inspect}" do
-      expect { subject.munge(arg) }.to raise_error Puppet::Error
+    [ false, :false, 'false', :no, 'no', 'FaLSE', 'nO' ].each do |arg|
+      it "should munge #{arg.inspect} as false" do
+        subject.munge(arg).should == false
+      end
+    end
+    [ nil, :undef, 'undef', '0', 0, '1', 1, 9284 ].each do |arg|
+      it "should fail to munge #{arg.inspect}" do
+        expect { subject.munge(arg) }.to raise_error Puppet::Error
+      end
     end
   end
 end

data/spec/unit/parser/ast/resourceparam_spec.rb

@@ -0,0 +1,51 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Parser::AST::ResourceParam do
+
+  ast = Puppet::Parser::AST
+
+  before :each do
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+    @scope = Puppet::Parser::Scope.new(@compiler)
+    @params = ast::ASTArray.new({})
+    @compiler.stubs(:add_override)
+  end
+
+  it "should evaluate the parameter value" do
+    object = mock 'object'
+    object.expects(:safeevaluate).with(@scope).returns('value')
+    ast::ResourceParam.new(:param => 'myparam', :value => object).evaluate(@scope)
+  end
+
+  it "should return a Puppet::Parser::Resource::Param on evaluation" do
+    object = mock 'object'
+    object.expects(:safeevaluate).with(@scope).returns('value')
+    evaled = ast::ResourceParam.new(:param => 'myparam', :value => object).evaluate(@scope)
+    evaled.should be_a(Puppet::Parser::Resource::Param)
+    evaled.name.to_s.should == 'myparam'
+    evaled.value.to_s.should == 'value'
+  end
+
+  it "should copy line numbers to Puppet::Parser::Resource::Param" do
+    object = mock 'object'
+    object.expects(:safeevaluate).with(@scope).returns('value')
+    evaled = ast::ResourceParam.new(:param => 'myparam', :value => object, :line => 42).evaluate(@scope)
+    evaled.line.should == 42
+  end
+
+  it "should copy source file to Puppet::Parser::Resource::Param" do
+    object = mock 'object'
+    object.expects(:safeevaluate).with(@scope).returns('value')
+    evaled = ast::ResourceParam.new(:param => 'myparam', :value => object, :file => 'foo.pp').evaluate(@scope)
+    evaled.file.should == 'foo.pp'
+  end
+
+  it "should change nil parameter values to undef" do
+    object = mock 'object'
+    object.expects(:safeevaluate).with(@scope).returns(nil)
+    evaled = ast::ResourceParam.new(:param => 'myparam', :value => object).evaluate(@scope)
+    evaled.should be_a(Puppet::Parser::Resource::Param)
+    evaled.value.should == :undef
+  end
+end

data/spec/unit/parser/compiler_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
@@ -106,22 +107,20 @@ describe Puppet::Parser::Compiler do
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
-  it "should clear the thread local caches before compile" do
+  it "should clear the global caches before compile" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     catalog.expects(:to_resource)
 
-    [:known_resource_types, :env_module_directories].each do |var|
-      Thread.current[var] = "rspec"
-    end
+    $known_resource_types = "rspec"
+    $env_module_directories = "rspec"
 
     Puppet::Parser::Compiler.compile(@node)
 
-    [:known_resource_types, :env_module_directories].each do |var|
-      Thread.current[var].should == nil
-    end
+    $known_resource_types = nil
+    $env_module_directories = nil
   end
 
   describe "when initializing" do
@@ -218,27 +217,6 @@ describe Puppet::Parser::Compiler do
       @compiler.catalog.server_version.should == "3"
     end
 
-    it "should evaluate any existing classes named in the node" do
-      classes = %w{one two three four}
-      main = stub 'main'
-      one = stub 'one', :name => "one"
-      three = stub 'three', :name => "three"
-      @node.stubs(:name).returns("whatever")
-      @node.stubs(:classes).returns(classes)
-      compile_stub(:evaluate_node_classes)
-
-      @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
-      @compiler.compile
-    end
-
-    it "should evaluate any parameterized classes named in the node" do
-      classes = {'foo'=>{'p1'=>'one'}, 'bar'=>{'p2'=>'two'}}
-      @node.stubs(:classes).returns(classes)
-      @compiler.expects(:evaluate_classes).with(classes, @compiler.topscope)
-      @compiler.compile
-    end
-
-
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
@@ -262,12 +240,6 @@ describe Puppet::Parser::Compiler do
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
-    it "should evaluate any node classes" do
-      @node.stubs(:classes).returns(%w{one two three four})
-      @compiler.expects(:evaluate_classes).with(%w{one two three four}, @compiler.topscope)
-      @compiler.send(:evaluate_node_classes)
-    end
-
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
@@ -655,7 +627,7 @@ describe Puppet::Parser::Compiler do
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
-        r2.tags.should =~ ['bar::foo', 'class', 'bar', 'foo']
+        r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
       end
     end
 
@@ -791,6 +763,102 @@ describe Puppet::Parser::Compiler do
     end
   end
 
+  describe "when evaluating node classes" do
+    include PuppetSpec::Compiler
+
+    describe "when provided classes in array format" do
+      let(:node) { Puppet::Node.new('someone', :classes => ['something']) }
+
+      describe "when the class exists" do
+        it "should succeed if the class is already included" do
+          manifest = <<-MANIFEST
+          class something {}
+          include something
+          MANIFEST
+
+          catalog = compile_to_catalog(manifest, node)
+
+          catalog.resource('Class', 'Something').should_not be_nil
+        end
+
+        it "should evaluate the class without parameters if it's not already included" do
+          manifest = "class something {}"
+
+          catalog = compile_to_catalog(manifest, node)
+
+          catalog.resource('Class', 'Something').should_not be_nil
+        end
+      end
+
+      it "should fail if the class doesn't exist" do
+        expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
+      end
+    end
+
+    describe "when provided classes in hash format" do
+      describe "for classes without parameters" do
+        let(:node) { Puppet::Node.new('someone', :classes => {'something' => {}}) }
+
+        describe "when the class exists" do
+          it "should succeed if the class is already included" do
+            manifest = <<-MANIFEST
+            class something {}
+            include something
+            MANIFEST
+
+            catalog = compile_to_catalog(manifest, node)
+
+            catalog.resource('Class', 'Something').should_not be_nil
+          end
+
+          it "should evaluate the class if it's not already included" do
+            manifest = <<-MANIFEST
+            class something {}
+            MANIFEST
+
+            catalog = compile_to_catalog(manifest, node)
+
+            catalog.resource('Class', 'Something').should_not be_nil
+          end
+        end
+
+        it "should fail if the class doesn't exist" do
+          expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
+        end
+      end
+
+      describe "for classes with parameters" do
+        let(:node) { Puppet::Node.new('someone', :classes => {'something' => {'configuron' => 'defrabulated'}}) }
+
+        describe "when the class exists" do
+          it "should fail if the class is already included" do
+            manifest = <<-MANIFEST
+            class something($configuron=frabulated) {}
+            include something
+            MANIFEST
+
+            expect { compile_to_catalog(manifest, node) }.to raise_error(Puppet::Error, /Class\[Something\] is already declared/)
+          end
+
+          it "should evaluate the class if it's not already included" do
+            manifest = <<-MANIFEST
+            class something($configuron=frabulated) {}
+            MANIFEST
+
+            catalog = compile_to_catalog(manifest, node)
+
+            resource = catalog.resource('Class', 'Something')
+            resource['configuron'].should == 'defrabulated'
+          end
+        end
+
+        it "should fail if the class doesn't exist" do
+          expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
+        end
+      end
+    end
+  end
+
   describe "when managing resource overrides" do
 
     before do

data/spec/unit/parser/eparser_adapter_spec.rb

@@ -365,42 +365,42 @@ describe Puppet::Parser do
   end
   context "when parsing method calls" do
     it "should parse method call with one param lambda" do
-      expect { @parser.parse("$a.foreach {|$a| debug $a }") }.to_not raise_error
+      expect { @parser.parse("$a.each |$a|{ debug $a }") }.to_not raise_error
     end
     it "should parse method call with two param lambda" do
-      expect { @parser.parse("$a.foreach {|$a,$b| debug $a }") }.to_not raise_error
+      expect { @parser.parse("$a.each |$a,$b|{ debug $a }") }.to_not raise_error
     end
     it "should parse method call with two param lambda and default value" do
-      expect { @parser.parse("$a.foreach {|$a,$b=1| debug $a }") }.to_not raise_error
+      expect { @parser.parse("$a.each |$a,$b=1|{ debug $a }") }.to_not raise_error
     end
     it "should parse method call without lambda (statement)" do
-      expect { @parser.parse("$a.foreach") }.to_not raise_error
+      expect { @parser.parse("$a.each") }.to_not raise_error
     end
     it "should parse method call without lambda (expression)" do
-      expect { @parser.parse("$x = $a.foreach + 1") }.to_not raise_error
+      expect { @parser.parse("$x = $a.each + 1") }.to_not raise_error
     end
     context "a receiver expression of type" do
       it "variable should be allowed" do
-        expect { @parser.parse("$a.foreach") }.to_not raise_error
+        expect { @parser.parse("$a.each") }.to_not raise_error
       end
       it "hasharrayaccess should be allowed" do
-        expect { @parser.parse("$a[0][1].foreach") }.to_not raise_error
+        expect { @parser.parse("$a[0][1].each") }.to_not raise_error
       end
       it "quoted text should be allowed" do
-        expect { @parser.parse("\"monkey\".foreach") }.to_not raise_error
-        expect { @parser.parse("'monkey'.foreach") }.to_not raise_error
+        expect { @parser.parse("\"monkey\".each") }.to_not raise_error
+        expect { @parser.parse("'monkey'.each") }.to_not raise_error
       end
       it "selector text should be allowed" do
-        expect { @parser.parse("$a ? { 'banana'=>[1,2,3]}.foreach") }.to_not raise_error
+        expect { @parser.parse("$a ? { 'banana'=>[1,2,3]}.each") }.to_not raise_error
       end
       it "function call should be allowed" do
-        expect { @parser.parse("duh(1,2,3).foreach") }.to_not raise_error
+        expect { @parser.parse("duh(1,2,3).each") }.to_not raise_error
       end
       it "method call should be allowed" do
         expect { @parser.parse("$a.foo.bar") }.to_not raise_error
       end
       it "chained method calls with lambda should be allowed" do
-        expect { @parser.parse("$a.foo{||}.bar{||}") }.to_not raise_error
+        expect { @parser.parse("$a.foo||{}.bar||{}") }.to_not raise_error
       end
     end
   end

data/spec/unit/parser/files_spec.rb

@@ -28,7 +28,7 @@ describe Puppet::Parser::Files do
       Puppet[:templatedir] = "/my/templates"
       Puppet[:modulepath] = "/one:/two"
       File.stubs(:directory?).returns(true)
-      FileTest.stubs(:exist?).returns(true)
+      Puppet::FileSystem::File.stubs(:exist?).returns(true)
       Puppet::Parser::Files.find_template("mymod/mytemplate").should == File.join(Puppet[:templatedir], "mymod/mytemplate")
     end
 
@@ -43,59 +43,59 @@ describe Puppet::Parser::Files do
     end
 
     it "should return unqualified templates if they exist in the template dir" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
       Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
     end
 
     it "should only return templates if they actually exist" do
-      FileTest.expects(:exist?).with("/my/templates/mytemplate").returns true
+      Puppet::FileSystem::File.expects(:exist?).with("/my/templates/mytemplate").returns true
       Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
       Puppet::Parser::Files.find_template("mytemplate").should == "/my/templates/mytemplate"
     end
 
     it "should return nil when asked for a template that doesn't exist" do
-      FileTest.expects(:exist?).with("/my/templates/mytemplate").returns false
+      Puppet::FileSystem::File.expects(:exist?).with("/my/templates/mytemplate").returns false
       Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
       Puppet::Parser::Files.find_template("mytemplate").should be_nil
     end
 
     it "should search in the template directories before modules" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(["/my/templates"])
       Puppet::Module.expects(:find).never
       Puppet::Parser::Files.find_template("mytemplate")
     end
 
     it "should accept relative templatedirs" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       Puppet[:templatedir] = "my/templates"
       File.expects(:directory?).with(File.expand_path("my/templates")).returns(true)
       Puppet::Parser::Files.find_template("mytemplate").should == File.expand_path("my/templates/mytemplate")
     end
 
     it "should use the environment templatedir if no module is found and an environment is specified" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates"])
       Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
     end
 
     it "should use first dir from environment templatedir if no module is found and an environment is specified" do
-      FileTest.stubs(:exist?).returns true
+      Puppet::FileSystem::File.stubs(:exist?).returns true
       Puppet::Parser::Files.stubs(:templatepath).with("myenv").returns(["/myenv/templates", "/two/templates"])
       Puppet::Parser::Files.find_template("mymod/mytemplate", "myenv").should == "/myenv/templates/mymod/mytemplate"
     end
 
     it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
       Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-      FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with("/one/templates/mytemplate").returns(true)
       Puppet::Parser::Files.find_template("mytemplate").should == "/one/templates/mytemplate"
     end
 
     it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
       Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-      FileTest.expects(:exist?).with("/one/templates/mytemplate").returns(false)
-      FileTest.expects(:exist?).with("/two/templates/mytemplate").returns(true)
+      Puppet::FileSystem::File.expects(:exist?).with("/one/templates/mytemplate").returns(false)
+      Puppet::FileSystem::File.expects(:exist?).with("/two/templates/mytemplate").returns(true)
       Puppet::Parser::Files.find_template("mytemplate").should == "/two/templates/mytemplate"
     end