puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/node/facts_spec.rb

@@ -1,18 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 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
+require 'matchers/json'
 
 describe Puppet::Node::Facts, "when indirecting" do
+  include JSONMatchers
+
   before do
     @facts = Puppet::Node::Facts.new("me")
   end
@@ -156,12 +149,12 @@ describe Puppet::Node::Facts, "when indirecting" do
         result['expiration'].should == facts.expiration.iso8601(9)
       end
 
-      it "should generate valid facts data against the facts schema", :unless => Puppet.features.microsoft_windows? do
+      it "should generate valid facts data against the facts schema" 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)
+        expect(facts.to_pson).to validate_against('api/schemas/facts.json')
       end
 
       it "should not include nil values" do

data/spec/unit/node_spec.rb

@@ -2,41 +2,39 @@
 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 Puppet::Node do
+  include JSONMatchers
 
-  describe "node schema" do
-    it "should validate against the json meta-schema" do
-      JSON::Validator.validate!(JSON_META_SCHEMA, NODE_SCHEMA)
-    end
-  end
-end
+  let(:environment) { Puppet::Node::Environment.create(:bar, [], '') }
+  let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
-describe Puppet::Node do
   it "should register its document type as Node" do
     PSON.registered_document_types["Node"].should equal(Puppet::Node)
   end
 
   describe "when managing its environment" do
     it "should use any set environment" do
-      Puppet::Node.new("foo", :environment => "bar").environment.name.should == :bar
+      Puppet.override(:environments => env_loader) do
+        Puppet::Node.new("foo", :environment => "bar").environment.should == environment
+      end
     end
 
     it "should support providing an actual environment instance" do
-      Puppet::Node.new("foo", :environment => Puppet::Node::Environment.new(:bar)).environment.name.should == :bar
+      Puppet::Node.new("foo", :environment => environment).environment.name.should == :bar
     end
 
     it "should determine its environment from its parameters if no environment is set" do
-      Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment.name.should == :bar
+      Puppet.override(:environments => env_loader) do
+        Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment.should == environment
+      end
     end
 
-    it "should use the default environment if no environment is provided" do
-      Puppet::Node.new("foo").environment.name.should == Puppet::Node::Environment.new.name
-    end
+    it "should use the configured environment if no environment is provided" do
+      Puppet[:environment] = environment.name.to_s
 
-    it "should always return an environment instance rather than a string" do
-      Puppet::Node.new("foo").environment.should be_instance_of(Puppet::Node::Environment)
+      Puppet.override(:environments => env_loader) do
+        Puppet::Node.new("foo").environment.should == environment
+      end
     end
 
     it "should allow the environment to be set after initialization" do
@@ -87,7 +85,7 @@ describe Puppet::Node do
                             :classes => ['erth', 'aiu'],
                             :parameters => {"hostname"=>"food"}
                            )
-    JSON::Validator.validate!(NODE_SCHEMA, node.to_pson)
+    expect(node.to_pson).to validate_against('api/schemas/node.json')
   end
 
   it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
@@ -95,7 +93,7 @@ describe Puppet::Node do
     node = Puppet::Node.new("hello",
                             :environment => 'kjhgrg'
                            )
-    JSON::Validator.validate!(NODE_SCHEMA, node.to_pson)
+    expect(node.to_pson).to validate_against('api/schemas/node.json')
   end
 
   describe "when converting to json" do
@@ -160,8 +158,10 @@ describe Puppet::Node do
     end
 
     it "should include the environment" do
-      @node.environment = "production"
-      Puppet::Node.should read_json_attribute('environment').from(@node.to_pson).as(Puppet::Node::Environment.new(:production))
+      Puppet.override(:environments => env_loader) do
+        @node.environment = environment
+        Puppet::Node.should read_json_attribute('environment').from(@node.to_pson).as(environment)
+      end
     end
   end
 end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe Puppet::Parser::AST::Collection do
   before :each do
     @mytype = Puppet::Resource::Type.new(:definition, "mytype")
-    @environment = Puppet::Node::Environment.new
+    @environment = Puppet::Node::Environment.create(:testing, [], '')
     @environment.known_resource_types.add @mytype
 
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foonode", :environment => @environment))

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

@@ -280,6 +280,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
 
   describe "when assigning" do
     it "should add a new key and value" do
+      Puppet.expects(:warning).once
       node     = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
       scope    = Puppet::Parser::Scope.new(compiler)
@@ -301,6 +302,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
     end
 
     it "should be able to return an array member when index is a stringified number" do
+      Puppet.expects(:warning).once
       node     = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
       scope    = Puppet::Parser::Scope.new(compiler)

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

@@ -97,7 +97,7 @@ describe Puppet::Parser::AST::Resource do
     describe "when generating qualified resources" do
       before do
         @scope = Puppet::Parser::Scope.new Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-        @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
+        @parser = Puppet::Parser::Parser.new(@scope.environment)
         ["one", "one::two", "three"].each do |name|
           @parser.environment.known_resource_types.add(Puppet::Resource::Type.new(:definition, name, {}))
         end

data/spec/unit/parser/compiler_spec.rb

@@ -66,13 +66,15 @@ describe Puppet::Parser::Compiler do
     now = Time.now
     Time.stubs(:now).returns(now)
 
-    @node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
-    @known_resource_types = Puppet::Resource::TypeCollection.new "development"
+    environment = Puppet::Node::Environment.create(:testing, [], '')
+    @node = Puppet::Node.new("testnode",
+                             :facts => Puppet::Node::Facts.new("facts", {}),
+                             :environment => environment)
+    @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
-    @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do

data/spec/unit/parser/files_spec.rb

@@ -6,6 +6,8 @@ require 'puppet/parser/files'
 describe Puppet::Parser::Files do
   include PuppetSpec::Files
 
+  let(:environment) { Puppet::Node::Environment.create(:testing, [], '') }
+
   before do
     @basepath = make_absolute("/somepath")
   end
@@ -13,117 +15,107 @@ describe Puppet::Parser::Files do
   describe "when searching for templates" do
     it "should return fully-qualified templates directly" do
       Puppet::Parser::Files.expects(:modulepath).never
-      Puppet::Parser::Files.find_template(@basepath + "/my/template").should == @basepath + "/my/template"
+      Puppet::Parser::Files.find_template(@basepath + "/my/template", environment).should == @basepath + "/my/template"
     end
 
     it "should return the template from the first found module" do
       mod = mock 'module'
-      Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-
       mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-      Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+      environment.expects(:module).with("mymod").returns mod
+
+      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/one/mymod/templates/mytemplate"
     end
 
     it "should return the file in the templatedir if it exists" do
       Puppet[:templatedir] = "/my/templates"
       Puppet[:modulepath] = "/one:/two"
       File.stubs(:directory?).returns(true)
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
-      Puppet::Parser::Files.find_template("mymod/mytemplate").should == File.join(Puppet[:templatedir], "mymod/mytemplate")
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == File.join(Puppet[:templatedir], "mymod/mytemplate")
     end
 
     it "should not raise an error if no valid templatedir exists and the template exists in a module" do
       mod = mock 'module'
-      Puppet::Node::Environment.new.expects(:module).with("mymod").returns mod
-
       mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-      Puppet::Parser::Files.stubs(:templatepath).with(nil).returns(nil)
+      environment.expects(:module).with("mymod").returns mod
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(nil)
 
-      Puppet::Parser::Files.find_template("mymod/mytemplate").should == "/one/mymod/templates/mytemplate"
+      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/one/mymod/templates/mytemplate"
     end
 
     it "should return unqualified templates if they exist in the template dir" do
-      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"
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
+
+      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/my/templates/mytemplate"
     end
 
     it "should only return templates if they actually exist" do
-      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"
+      Puppet::FileSystem.expects(:exist?).with("/my/templates/mytemplate").returns true
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
+      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/my/templates/mytemplate"
     end
 
     it "should return nil when asked for a template that doesn't exist" do
-      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
-      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")
+      Puppet::FileSystem.expects(:exist?).with("/my/templates/mytemplate").returns false
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
+      Puppet::Parser::Files.find_template("mytemplate", environment).should be_nil
     end
 
     it "should accept relative templatedirs" do
-      Puppet::FileSystem::File.stubs(:exist?).returns true
+      Puppet::FileSystem.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")
+      Puppet::Parser::Files.find_template("mytemplate", environment).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
-      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"
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/myenv/templates"])
+      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).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
-      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"
+      Puppet::FileSystem.stubs(:exist?).returns true
+      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/myenv/templates", "/two/templates"])
+      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).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"])
-      Puppet::FileSystem::File.expects(:exist?).with("/one/templates/mytemplate").returns(true)
-      Puppet::Parser::Files.find_template("mytemplate").should == "/one/templates/mytemplate"
+      Puppet::FileSystem.expects(:exist?).with("/one/templates/mytemplate").returns(true)
+      Puppet::Parser::Files.find_template("mytemplate", environment).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"])
-      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"
+      Puppet::FileSystem.expects(:exist?).with("/one/templates/mytemplate").returns(false)
+      Puppet::FileSystem.expects(:exist?).with("/two/templates/mytemplate").returns(true)
+      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/two/templates/mytemplate"
     end
 
     it "should use the node environment if specified" do
       mod = mock 'module'
-      Puppet::Node::Environment.new("myenv").expects(:module).with("mymod").returns mod
+      environment.expects(:module).with("mymod").returns mod
 
       mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
 
-      Puppet::Parser::Files.find_template("mymod/envtemplate", "myenv").should == "/my/modules/mymod/templates/envtemplate"
+      Puppet::Parser::Files.find_template("mymod/envtemplate", environment).should == "/my/modules/mymod/templates/envtemplate"
     end
 
     it "should return nil if no template can be found" do
-      Puppet::Parser::Files.find_template("foomod/envtemplate", "myenv").should be_nil
+      Puppet::Parser::Files.find_template("foomod/envtemplate", environment).should be_nil
     end
-
-    after { Puppet.settings.clear }
   end
 
   describe "when searching for manifests" do
     it "should ignore invalid modules" do
       mod = mock 'module'
-      env = Puppet::Node::Environment.new
-      env.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
+      environment.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
       Puppet.expects(:value).with(:modulepath).never
       Dir.stubs(:glob).returns %w{foo}
 
-      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", env)
+      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", environment)
     end
   end
 
@@ -134,8 +126,6 @@ describe Puppet::Parser::Files do
       mod.stubs(:match_manifests).with("init.pp").returns(["/one/#{name}/manifests/init.pp"])
     end
 
-    let(:environment) { Puppet::Node::Environment.new }
-
     it "returns no files when no module is found" do
       module_name, files = Puppet::Parser::Files.find_manifests_in_modules("not_here_module/foo", environment)
       expect(files).to be_empty
@@ -150,7 +140,7 @@ describe Puppet::Parser::Files do
     end
 
     it "does not find the module when it is a different environment" do
-      different_env = Puppet::Node::Environment.new("different")
+      different_env = Puppet::Node::Environment.create(:different, [], '')
       a_module_in_environment(environment, "mymod")
 
       Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", different_env).should_not include("mymod")

data/spec/unit/parser/functions/defined_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/pops'
 
 describe "the 'defined' function" do
   before :all do
@@ -7,46 +8,107 @@ describe "the 'defined' function" do
   end
 
   before :each do
-    Puppet::Node::Environment.stubs(:current).returns(nil)
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(@compiler)
   end
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("defined").should == "function_defined"
+  it "exists" do
+    expect(Puppet::Parser::Functions.function("defined")).to be_eql("function_defined")
   end
 
-  it "should be true when the name is defined as a class" do
+  it "is true when the name is defined as a class" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
-    @scope.function_defined(["yayness"]).should be_true
+    expect(@scope.function_defined(["yayness"])).to be_true
   end
 
-  it "should be true when the name is defined as a definition" do
+  it "is true when the name is defined as a definition" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-    @scope.function_defined(["yayness"]).should be_true
+    expect(@scope.function_defined(["yayness"])).to be_true
   end
 
-  it "should be true when the name is defined as a builtin type" do
-    @scope.function_defined(["file"]).should be_true
+  it "is true when the name is defined as a builtin type" do
+    expect(@scope.function_defined(["file"])).to be_true
   end
 
-
-  it "should be true when any of the provided names are defined" do
+  it "is true when any of the provided names are defined" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-    @scope.function_defined(["meh", "yayness", "booness"]).should be_true
+    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_true
   end
 
-  it "should be false when a single given name is not defined" do
-    @scope.function_defined(["meh"]).should be_false
+  it "is false when a single given name is not defined" do
+    expect(@scope.function_defined(["meh"])).to be_false
   end
 
-  it "should be false when none of the names are defined" do
-    @scope.function_defined(["meh", "yayness", "booness"]).should be_false
+  it "is false when none of the names are defined" do
+    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_false
   end
 
-  it "should be true when a resource reference is provided and the resource is in the catalog" do
+  it "is true when a resource reference is provided and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
-    @scope.function_defined([resource]).should be_true
+    expect(@scope.function_defined([resource])).to be_true
+  end
+
+  context "with string variable references" do
+    it "is true when variable exists in scope" do
+      @scope['x'] = 'something'
+      expect(@scope.function_defined(['$x'])).to be_true
+    end
+
+    it "is true when at least one variable exists in scope" do
+      @scope['x'] = 'something'
+      expect(@scope.function_defined(['$y', '$x', '$z'])).to be_true
+    end
+
+    it "is false when variable does not exist in scope" do
+      expect(@scope.function_defined(['$x'])).to be_false
+    end
+  end
+
+  context "with future parser" do
+    before(:each) do
+      Puppet[:parser] = 'future'
+    end
+
+    it "is true when a future resource type reference is provided, and the resource is in the catalog" do
+      resource = Puppet::Resource.new("file", "/my/file")
+      @compiler.add_resource(@scope, resource)
+
+      resource_type = Puppet::Pops::Types::TypeFactory.resource('file', '/my/file')
+      expect(@scope.function_defined([resource_type])).to be_true
+    end
+
+    it "raises an argument error if you ask if Resource is defined" do
+      resource_type = Puppet::Pops::Types::TypeFactory.resource
+      expect { @scope.function_defined([resource_type]) }.to raise_error(ArgumentError, /reference to all.*type/)
+    end
+
+    it "is true if referencing a built in type" do
+      resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+      expect(@scope.function_defined([resource_type])).to be_true
+    end
+
+    it "is true if referencing a defined type" do
+      @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
+      resource_type = Puppet::Pops::Types::TypeFactory.resource('yayness')
+      expect(@scope.function_defined([resource_type])).to be_true
+    end
+
+    it "is false if referencing an undefined type" do
+      resource_type = Puppet::Pops::Types::TypeFactory.resource('barbershops')
+      expect(@scope.function_defined([resource_type])).to be_false
+    end
+
+    it "is true when a future class reference type is provided" do
+      @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "cowabunga")
+
+      class_type = Puppet::Pops::Types::TypeFactory.host_class("cowabunga")
+      expect(@scope.function_defined([class_type])).to be_true
+    end
+
+    it "raises an argument error if you ask if Class is defined" do
+      class_type = Puppet::Pops::Types::TypeFactory.host_class
+      expect { @scope.function_defined([class_type]) }.to raise_error(ArgumentError, /reference to all.*class/)
+    end
   end
 end