puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/rails/host_spec.rb

@@ -40,7 +40,7 @@ describe "Puppet::Rails::Host", :if => can_use_scratch_database? do
 
     it "should stringify the environment" do
       host = Puppet::Rails::Host.new
-      host.environment = Puppet::Node::Environment.new("production")
+      host.environment = Puppet::Node::Environment.create(:production, [], '')
       host.environment.class.should == String
     end
 

data/spec/unit/rails/param_value_spec.rb

@@ -12,6 +12,10 @@ describe "Puppet::Rails::ParamValue", :if => can_use_scratch_database? do
     Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
   end
 
+  after do
+    Puppet::Rails.teardown
+  end
+
   describe "when creating initial parameter values" do
     it "should return an array of hashes" do
       Puppet::Rails::ParamValue.from_parser_param(:myparam, %w{a b})[0].should be_instance_of(Hash)

data/spec/unit/relationship_spec.rb

@@ -211,18 +211,18 @@ describe Puppet::Relationship, "when converting from pson" do
   # LAK:NOTE For all of these tests, we convert back to the edge so we can
   # trap the actual data structure then.
   it "should pass the source in as the first argument" do
-    Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").source.should == "mysource"
+    Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source.should == "mysource"
   end
 
   it "should pass the target in as the second argument" do
-    Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
+    Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
   end
 
   it "should pass the event as an argument if it's provided" do
-    Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
+    Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
   end
 
   it "should pass the callback as an argument if it's provided" do
-    Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
+    Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
   end
 end

data/spec/unit/reports/http_spec.rb

@@ -46,19 +46,30 @@ describe processor do
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      connection.expects(:post).with(report_path, anything, anything).returns(httpok)
+      connection.expects(:post).with(report_path, anything, anything, {}).returns(httpok)
+
+      subject.process
+    end
+
+    it "should use the username and password specified by the 'reporturl' setting" do
+      Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
+
+      connection.expects(:post).with(anything, anything, anything, :basic_auth => {
+        :user => 'user',
+        :password => 'pass'
+      }).returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      connection.expects(:post).with(anything, subject.to_yaml, anything).returns(httpok)
+      connection.expects(:post).with(anything, subject.to_yaml, anything, {}).returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml")).returns(httpok)
+      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), {}).returns(httpok)
 
       subject.process
     end

data/spec/unit/reports/rrdgraph_spec.rb

@@ -9,7 +9,6 @@ describe processor do
   include PuppetSpec::Files
   before do
     Puppet[:rrddir] = tmpdir('rrdgraph')
-    Puppet.settings.use :master
   end
 
   after do

data/spec/unit/reports/store_spec.rb

@@ -47,7 +47,7 @@ describe processor do
 
     it "rejects invalid hostnames" do
       @report.host = ".."
-      Puppet::FileSystem::File.expects(:exist?).never
+      Puppet::FileSystem.expects(:exist?).never
       Tempfile.expects(:new).never
       expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
@@ -55,7 +55,7 @@ describe processor do
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
-      Puppet::FileSystem::File.expects(:unlink).never
+      Puppet::FileSystem.expects(:unlink).never
       expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end

data/spec/unit/resource/catalog_spec.rb

@@ -2,19 +2,10 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
-# the json-schema gem doesn't support windows
-if not Puppet.features.microsoft_windows?
-  CATALOG_SCHEMA = JSON.parse(File.read(File.join(File.dirname(__FILE__), '../../../api/schemas/catalog.json')))
-
-  describe "catalog schema" do
-    it "should validate against the json meta-schema" do
-      JSON::Validator.validate!(JSON_META_SCHEMA, CATALOG_SCHEMA)
-    end
-  end
-
-end
+require 'matchers/json'
 
 describe Puppet::Resource::Catalog, "when compiling" do
+  include JSONMatchers
   include PuppetSpec::Files
 
   before do
@@ -736,43 +727,40 @@ describe Puppet::Resource::Catalog, "when compiling" do
 end
 
 describe Puppet::Resource::Catalog, "when converting a resource catalog to pson" do
+  include JSONMatchers
   include PuppetSpec::Compiler
 
-  def validate_json_for_catalog(catalog)
-    JSON::Validator.validate!(CATALOG_SCHEMA, catalog.to_pson)
-  end
-
-  it "should validate an empty catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate an empty catalog against the schema" do
     empty_catalog = compile_to_catalog("")
-    validate_json_for_catalog(empty_catalog)
+    expect(empty_catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a noop catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a noop catalog against the schema" do
     noop_catalog = compile_to_catalog("create_resources('file', {})")
-    validate_json_for_catalog(noop_catalog)
+    expect(noop_catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a single resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a single resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
-    validate_json_for_catalog(catalog)
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a virtual resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a virtual resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
-    validate_json_for_catalog(catalog)
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a single exported resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a single exported resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
-    validate_json_for_catalog(catalog)
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a two resource catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a two resource catalog against the schema" do
     catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
-    validate_json_for_catalog(catalog)
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 
-  it "should validate a two parameter class catalog against the schema", :unless => Puppet.features.microsoft_windows? do
+  it "should validate a two parameter class catalog against the schema" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class multi_param_class ($one, $two) {
         notify {'foo':
@@ -785,7 +773,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to pson"
         two => 'world',
       }
     MANIFEST
-    validate_json_for_catalog(catalog)
+    expect(catalog.to_pson).to validate_against('api/schemas/catalog.json')
   end
 end
 

data/spec/unit/resource/status_spec.rb

@@ -181,7 +181,7 @@ describe Puppet::Resource::Status do
 
     @status.containment_path.should == @containment_path
 
-    tripped = Puppet::Resource::Status.from_pson(PSON.parse(@status.to_pson))
+    tripped = Puppet::Resource::Status.from_data_hash(PSON.parse(@status.to_pson))
 
     tripped.title.should == @status.title
     tripped.containment_path.should == @status.containment_path

data/spec/unit/resource/type_collection_spec.rb

@@ -7,39 +7,20 @@ require 'puppet/resource/type'
 describe Puppet::Resource::TypeCollection do
   include PuppetSpec::Files
 
+  let(:environment) { Puppet::Node::Environment.create(:testing, [], '') }
+
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
-    @code = Puppet::Resource::TypeCollection.new("env")
-  end
-
-  it "should require an environment at initialization" do
-    env = Puppet::Node::Environment.new("testing")
-    Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
-  end
-
-  it "should convert the environment into an environment instance if a string is provided" do
-    env = Puppet::Node::Environment.new("testing")
-    Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
-  end
-
-  it "should create a 'loader' at initialization" do
-    Puppet::Resource::TypeCollection.new("testing").loader.should be_instance_of(Puppet::Parser::TypeLoader)
-  end
-
-  it "should be able to add a resource type" do
-    Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
+    @code = Puppet::Resource::TypeCollection.new(environment)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-    loader.expects(:add).with "foo"
-    loader.expects(:add).with "bar"
-    loader << "foo" << "bar"
+    @code.expects(:add).with "foo"
+    @code.expects(:add).with "bar"
+    @code << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
-    loader = Puppet::Resource::TypeCollection.new("env")
-
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
@@ -96,7 +77,7 @@ describe Puppet::Resource::TypeCollection do
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
-    loader = Puppet::Resource::TypeCollection.new("env")
+    loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
@@ -200,14 +181,14 @@ describe Puppet::Resource::TypeCollection do
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
-        loader = Puppet::Resource::TypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "foo")
 
         loader.add(instance).should equal(instance)
       end
 
       it "should retrieve #{data} insensitive to case" do
-        loader = Puppet::Resource::TypeCollection.new("env")
+        loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "Bar")
 
         loader.add instance
@@ -216,75 +197,75 @@ describe Puppet::Resource::TypeCollection do
       end
 
       it "should return nil when asked for a #{data} that has not been added" do
-        Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
+        Puppet::Resource::TypeCollection.new(environment).send(data, "foo").should be_nil
       end
     end
   end
 
   describe "when finding a qualified instance" do
     it "should return any found instance if the instance name is fully qualified" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("namespace", "::foo::bar").should equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       loader.find_hostclass("namespace", "::foo::bar").should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
       loader.find_hostclass("", "foo").should equal(instance)
     end
 
     it "should return the partially qualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo", "bar::baz").should equal(instance)
     end
 
     it "should be able to find partially qualified objects in any of the provided namespaces" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass(["nons", "foo", "otherns"], "bar::baz").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo", "bar").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo::bar::baz", "bar").should equal(instance)
     end
 
     it "should should return the partially qualified object if it exists in the parent namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "bar::baz").should equal(instance)
     end
 
     it "should return the qualified object if it exists in the root namespace" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "foo::bar::baz").should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
-      loader = Puppet::Resource::TypeCollection.new("env")
+      loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar", "eh").should be_nil
@@ -292,7 +273,7 @@ describe Puppet::Resource::TypeCollection do
 
     describe "when topscope has a class that has the same name as a local class" do
       before do
-        @loader = Puppet::Resource::TypeCollection.new("env")
+        @loader = Puppet::Resource::TypeCollection.new(environment)
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
@@ -312,7 +293,7 @@ describe Puppet::Resource::TypeCollection do
     end
 
     it "should not look in the local scope for classes when the name is qualified" do
-        @loader = Puppet::Resource::TypeCollection.new("env")
+        @loader = Puppet::Resource::TypeCollection.new(environment)
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
         @loader.find_hostclass("foo", "::bar").should == nil
@@ -322,24 +303,24 @@ describe Puppet::Resource::TypeCollection do
 
   it "should be able to find nodes" do
     node = Puppet::Resource::Type.new(:node, "bar")
-    loader = Puppet::Resource::TypeCollection.new("env")
+    loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add(node)
     loader.find_node(stub("ignored"), "bar").should == node
   end
 
   it "should indicate whether any nodes are defined" do
-    loader = Puppet::Resource::TypeCollection.new("env")
+    loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
     loader.should be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
-    Puppet::Resource::TypeCollection.new("env").should_not be_nodes
+    Puppet::Resource::TypeCollection.new(environment).should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
-      @loader = Puppet::Resource::TypeCollection.new("env")
+      @loader = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should return any node whose name exactly matches the provided node name" do
@@ -368,7 +349,7 @@ describe Puppet::Resource::TypeCollection do
 
   describe "when managing files" do
     before do
-      @loader = Puppet::Resource::TypeCollection.new("env")
+      @loader = Puppet::Resource::TypeCollection.new(environment)
       Puppet::Util::WatchedFile.stubs(:new).returns stub("watched_file")
     end
 
@@ -409,7 +390,7 @@ describe Puppet::Resource::TypeCollection do
 
   describe "when determining the configuration version" do
     before do
-      @code = Puppet::Resource::TypeCollection.new("env")
+      @code = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should default to the current time" do

data/spec/unit/resource/type_spec.rb

@@ -2,19 +2,11 @@
 require 'spec_helper'
 require 'puppet/resource/type'
 
-# the json-schema gem doesn't support windows
-if not Puppet.features.microsoft_windows?
-  RESOURCE_TYPE_SCHEMA = JSON.parse(File.read(File.join(File.dirname(__FILE__), '../../../api/schemas/resource_type.json')))
-
-  describe "resource type schema" do
-    it "should validate against the json meta-schema" do
-      JSON::Validator.validate!(JSON_META_SCHEMA, RESOURCE_TYPE_SCHEMA)
-    end
-  end
-
-end
+require 'matchers/json'
 
 describe Puppet::Resource::Type do
+  include JSONMatchers
+
   it "should have a 'name' attribute" do
     Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
   end
@@ -42,20 +34,16 @@ describe Puppet::Resource::Type do
   end
 
   describe "when converting to json" do
-    def validate_json_for_type(type)
-      JSON::Validator.validate!(RESOURCE_TYPE_SCHEMA, type.to_pson)
-    end
-
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     def from_json(json)
-      Puppet::Resource::Type.from_pson(json)
+      Puppet::Resource::Type.from_data_hash(json)
     end
 
     def double_convert
-      Puppet::Resource::Type.from_pson(PSON.parse(@type.to_pson))
+      Puppet::Resource::Type.from_data_hash(PSON.parse(@type.to_pson))
     end
 
     it "should include the name and type" do
@@ -63,18 +51,18 @@ describe Puppet::Resource::Type do
       double_convert.type.should == @type.type
     end
 
-    it "should validate with only name and kind", :unless => Puppet.features.microsoft_windows? do
-      validate_json_for_type(@type)
+    it "should validate with only name and kind" do
+      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
     end
 
-    it "should validate with all fields set", :unless => Puppet.features.microsoft_windows? do
+    it "should validate with all fields set" do
       @type.set_arguments("one" => nil, "two" => "foo")
       @type.line = 100
       @type.doc = "A weird type"
       @type.file = "/etc/manifests/thing.pp"
       @type.parent = "one::two"
 
-      validate_json_for_type(@type)
+      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
     end
 
     it "should include any arguments" do
@@ -359,14 +347,15 @@ describe Puppet::Resource::Type do
 
   describe "when describing and managing parent classes" do
     before do
-      @krt = Puppet::Node::Environment.new.known_resource_types
+      environment = Puppet::Node::Environment.create(:testing, [], '')
+      @krt = environment.known_resource_types
       @parent = Puppet::Resource::Type.new(:hostclass, "bar")
       @krt.add @parent
 
       @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
       @krt.add @child
 
-      @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")))
+      @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo", :environment => environment)))
     end
 
     it "should be able to define a parent" do