puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/indirector/node/active_record_spec.rb

@@ -9,7 +9,7 @@ describe "Puppet::Node::ActiveRecord", :if => Puppet.features.rails? && Puppet.f
   let(:nodename) { "mynode" }
   let(:fact_values) { {:afact => "a value"} }
   let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
-  let(:environment) { Puppet::Node::Environment.new("myenv") }
+  let(:environment) { Puppet::Node::Environment.create(:myenv, [], '') }
   let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
   let(:node_indirection) { Puppet::Node::ActiveRecord.new }
 

data/spec/unit/indirector/node/ldap_spec.rb

@@ -6,7 +6,7 @@ require 'puppet/indirector/node/ldap'
 describe Puppet::Node::Ldap do
   let(:nodename) { "mynode.domain.com" }
   let(:node_indirection) { Puppet::Node::Ldap.new }
-  let(:environment) { Puppet::Node::Environment.new("myenv") }
+  let(:environment) { Puppet::Node::Environment.create(:myenv, [], '') }
   let(:fact_values) { {:afact => "a value", "one" => "boo"} }
   let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
 
@@ -176,10 +176,13 @@ describe Puppet::Node::Ldap do
       end
 
       it "should set the node's environment to the environment of the results" do
-        result_env = Puppet::Node::Environment.new("local_test")
+        result_env = Puppet::Node::Environment.create(:local_test, [], '')
         Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => result_env).returns(facts)
         @result[:environment] = "local_test"
-        node_indirection.find(request).environment.should == result_env
+
+        Puppet.override(:environments => Puppet::Environments::Static.new(result_env)) do
+          node_indirection.find(request).environment.should == result_env
+        end
       end
 
       it "should retain false parameter values" do
@@ -256,17 +259,20 @@ describe Puppet::Node::Ldap do
         end
 
         it "should use the parent's environment if the node has none" do
-          env = Puppet::Node::Environment.new("parent")
+          env = Puppet::Node::Environment.create(:parent, [], '')
           @entry[:parent] = "parent"
 
           @parent[:environment] = "parent"
 
           Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => env).returns(facts)
-          node_indirection.find(request).environment.should == env
+
+          Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
+            node_indirection.find(request).environment.should == env
+          end
         end
 
         it "should prefer the node's environment to the parent's" do
-          child_env = Puppet::Node::Environment.new("child")
+          child_env = Puppet::Node::Environment.create(:child, [], '')
           @entry[:parent] = "parent"
           @entry[:environment] = "child"
 
@@ -274,7 +280,10 @@ describe Puppet::Node::Ldap do
 
           Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => child_env).returns(facts)
 
-          node_indirection.find(request).environment.should == child_env
+          Puppet.override(:environments => Puppet::Environments::Static.new(child_env)) do
+
+            node_indirection.find(request).environment.should == child_env
+          end
         end
 
         it "should recursively look up parent information" do

data/spec/unit/indirector/node/msgpack_spec.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/node'
+require 'puppet/indirector/node/msgpack'
+
+describe Puppet::Node::Msgpack, :if => Puppet.features.msgpack? do
+  it "should be a subclass of the Msgpack terminus" do
+    Puppet::Node::Msgpack.superclass.should equal(Puppet::Indirector::Msgpack)
+  end
+
+  it "should have documentation" do
+    Puppet::Node::Msgpack.doc.should_not be_nil
+  end
+
+  it "should be registered with the configuration store indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:node)
+    Puppet::Node::Msgpack.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :msgpack" do
+    Puppet::Node::Msgpack.name.should == :msgpack
+  end
+end

data/spec/unit/indirector/node/plain_spec.rb

@@ -7,7 +7,7 @@ describe Puppet::Node::Plain do
   let(:nodename) { "mynode" }
   let(:fact_values) { {:afact => "a value"} }
   let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
-  let(:environment) { Puppet::Node::Environment.new("myenv") }
+  let(:environment) { Puppet::Node::Environment.create(:myenv, [], '') }
   let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
   let(:node_indirection) { Puppet::Node::Plain.new }
 

data/spec/unit/indirector/queue_spec.rb

@@ -107,7 +107,7 @@ describe Puppet::Indirector::Queue do
       expect { @store_class.subscribe {|o| o } }.to_not raise_error
 
       @logs.length.should == 1
-      @logs.first.message.should =~ /Error occured with subscription to queue my_queue for indirection my_queue: ArgumentError/
+      @logs.first.message.should =~ /Error occurred with subscription to queue my_queue for indirection my_queue: ArgumentError/
       @logs.first.level.should == :err
     end
   end

data/spec/unit/indirector/report/msgpack_spec.rb

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/transaction/report'
+require 'puppet/indirector/report/msgpack'
+
+describe Puppet::Transaction::Report::Msgpack, :if => Puppet.features.msgpack? do
+  it "should be a subclass of the Msgpack terminus" do
+    Puppet::Transaction::Report::Msgpack.superclass.should equal(Puppet::Indirector::Msgpack)
+  end
+
+  it "should have documentation" do
+    Puppet::Transaction::Report::Msgpack.doc.should_not be_nil
+  end
+
+  it "should be registered with the report indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:report)
+    Puppet::Transaction::Report::Msgpack.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :msgpack" do
+    Puppet::Transaction::Report::Msgpack.name.should == :msgpack
+  end
+
+  it "should unconditionally save/load from the --lastrunreport setting" do
+    subject.path(:me).should == Puppet[:lastrunreport]
+  end
+end

data/spec/unit/indirector/request_spec.rb

@@ -5,6 +5,7 @@ require 'puppet/indirector/request'
 require 'puppet/util/pson'
 
 describe Puppet::Indirector::Request do
+  include JSONMatchers
 
   describe "when registering the document type" do
     it "should register its document type with JSON" do
@@ -217,21 +218,28 @@ describe Puppet::Indirector::Request do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key.should == URI.escape("my key")
   end
 
-  it "should have an environment accessor" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").should respond_to(:environment)
-  end
-
   it "should set its environment to an environment instance when a string is specified as its environment" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
+    env = Puppet::Node::Environment.create(:foo, [], '')
+
+    Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
+      Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == env
+    end
   end
 
   it "should use any passed in environment instances as its environment" do
-    env = Puppet::Node::Environment.new("foo")
+    env = Puppet::Node::Environment.create(:foo, [], '')
+
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
   end
 
-  it "should use the default environment when none is provided" do
-    Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).environment.should equal(Puppet::Node::Environment.new)
+  it "should use the configured environment when none is provided" do
+    configured = Puppet::Node::Environment.create(:foo, [], '')
+
+    Puppet[:environment] = "foo"
+
+    Puppet.override(:environments => Puppet::Environments::Static.new(configured)) do
+      Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment.should == configured
+    end
   end
 
   it "should support converting its options to a hash" do

data/spec/unit/indirector/rest_spec.rb

@@ -164,10 +164,6 @@ describe Puppet::Indirector::REST do
     Puppet::Indirector::Request.new(:test_model, :save, key, instance, options)
   end
 
-  it "should include the v1 REST API module" do
-    Puppet::Indirector::REST.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
-  end
-
   it "should have a method for specifying what setting a subclass should use to retrieve its server" do
     terminus_class.should respond_to(:use_server_setting)
   end

data/spec/unit/indirector/ssl_file_spec.rb

@@ -121,9 +121,9 @@ describe Puppet::Indirector::SslFile do
     describe "when finding certificates on disk" do
       describe "and no certificate is present" do
         it "should return nil" do
-          Puppet::FileSystem::File.expects(:exist?).with(@path).returns(true)
+          Puppet::FileSystem.expects(:exist?).with(@path).returns(true)
           Dir.expects(:entries).with(@path).returns([])
-          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns(false)
+          Puppet::FileSystem.expects(:exist?).with(@certpath).returns(false)
 
           @searcher.find(@request).should be_nil
         end
@@ -139,7 +139,7 @@ describe Puppet::Indirector::SslFile do
 
         context "is readable" do
           it "should return an instance of the model, which it should use to read the certificate" do
-            Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns true
+            Puppet::FileSystem.expects(:exist?).with(@certpath).returns true
 
             model.expects(:new).with("myname").returns cert
             cert.expects(:read).with(@certpath)
@@ -150,7 +150,7 @@ describe Puppet::Indirector::SslFile do
 
         context "is unreadable" do
           it "should raise an exception" do
-            Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns(true)
+            Puppet::FileSystem.expects(:exist?).with(@certpath).returns(true)
 
             model.expects(:new).with("myname").returns cert
             cert.expects(:read).with(@certpath).raises(Errno::EACCES)
@@ -171,9 +171,9 @@ describe Puppet::Indirector::SslFile do
         # the support for upper-case certs can be removed around mid-2009.
         it "should rename the existing file to the lower-case path" do
           @path = @searcher.path("myhost")
-          Puppet::FileSystem::File.expects(:exist?).with(@path).returns(false)
+          Puppet::FileSystem.expects(:exist?).with(@path).returns(false)
           dir, file = File.split(@path)
-          Puppet::FileSystem::File.expects(:exist?).with(dir).returns true
+          Puppet::FileSystem.expects(:exist?).with(dir).returns true
           Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
 
           File.expects(:rename).with(File.join(dir, file.upcase), @path)
@@ -256,7 +256,7 @@ describe Puppet::Indirector::SslFile do
     describe "when destroying certificates" do
       describe "that do not exist" do
         before do
-          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns false
+          Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@certpath)).returns false
         end
 
         it "should return false" do
@@ -266,14 +266,15 @@ describe Puppet::Indirector::SslFile do
 
       describe "that exist" do
         it "should unlink the certificate file" do
-          Puppet::FileSystem::File.expects(:exist?).with(@certpath).returns true
-          Puppet::FileSystem::File.expects(:unlink).with(@certpath)
+          path = Puppet::FileSystem.pathname(@certpath)
+          Puppet::FileSystem.expects(:exist?).with(path).returns true
+          Puppet::FileSystem.expects(:unlink).with(path)
           @searcher.destroy(@request)
         end
 
         it "should log that is removing the file" do
-          Puppet::FileSystem::File.stubs(:exist?).returns true
-          Puppet::FileSystem::File.stubs(:unlink)
+          Puppet::FileSystem.stubs(:exist?).returns true
+          Puppet::FileSystem.stubs(:unlink)
           Puppet.expects(:notice)
           @searcher.destroy(@request)
         end

data/spec/unit/indirector/yaml_spec.rb

@@ -149,15 +149,15 @@ describe Puppet::Indirector::Yaml do
       end
 
       it "should unlink the right yaml file if it exists" do
-        Puppet::FileSystem::File.expects(:exist?).with(path).returns true
-        Puppet::FileSystem::File.expects(:unlink).with(path)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:unlink).with(path)
 
         @store.destroy(@request)
       end
 
       it "should not unlink the yaml file if it does not exists" do
-        Puppet::FileSystem::File.expects(:exist?).with(path).returns false
-        Puppet::FileSystem::File.expects(:unlink).with(path).never
+        Puppet::FileSystem.expects(:exist?).with(path).returns false
+        Puppet::FileSystem.expects(:unlink).with(path).never
 
         @store.destroy(@request)
       end

data/spec/unit/man_spec.rb

@@ -0,0 +1,32 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:man, :current] do
+  let(:pager) { '/path/to/our/pager' }
+
+  around do |example|
+    oldpager = ENV['MANPAGER']
+    ENV['MANPAGER'] = pager
+    example.run
+    ENV['MANPAGER'] = oldpager
+  end
+
+  it "exits with 0 when generating man documentation for each available application" do
+    Puppet::Util.stubs(:which).with('ronn').returns(nil)
+    Puppet::Util.stubs(:which).with(pager).returns(pager)
+
+    Puppet::Application.available_application_names.each do |name|
+      next if %w{man face_base indirection_base}.include? name
+
+      klass = Puppet::Application.find('man')
+      app = klass.new(Puppet::Util::CommandLine.new('puppet', ['man', name]))
+
+      expect do
+        IO.stubs(:popen).with(pager, anything).yields($stdout)
+
+        expect { app.run }.to exit_with(0)
+      end.to_not have_printed(/undefined method `gsub'/)
+    end
+  end
+end

data/spec/unit/module_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Module do
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
-    Puppet::FileSystem::File.stubs(:exist?).returns false
+    Puppet::FileSystem.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
@@ -90,14 +90,13 @@ describe Puppet::Module do
 
   describe "when finding unmet dependencies" do
     before do
-      Puppet::FileSystem::File.unstub(:exist?)
+      Puppet::FileSystem.unstub(:exist?)
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
 
     it "should list modules that are missing" do
       metadata_file = "#{@modpath}/needy/metadata.json"
-      Puppet::FileSystem::File.expects(:exist?).twice.with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -119,7 +118,6 @@ describe Puppet::Module do
 
     it "should list modules that are missing and have invalid names" do
       metadata_file = "#{@modpath}/needy/metadata.json"
-      Puppet::FileSystem::File.expects(:exist?).with(metadata_file).twice.returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -140,42 +138,43 @@ describe Puppet::Module do
     end
 
     it "should list modules with unmet version requirement" do
-      ['foobar', 'foobaz'].each do |mod_name|
-        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
-        Puppet::FileSystem::File.stubs(:exist?).with(metadata_file).returns true
-      end
+      env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
       mod = PuppetSpec::Modules.create(
-        'foobar',
+        'test_gte_req',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar"
           }]
-        }
+        },
+        :environment => env
       )
       mod2 = PuppetSpec::Modules.create(
-        'foobaz',
+        'test_specific_req',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => "1.0.0",
             "name" => "baz/foobar"
           }]
-        }
+        },
+        :environment => env
       )
 
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
-        :metadata => { :version => '2.0.0', :author  => 'baz' }
+        :metadata => { :version => '2.0.0', :author  => 'baz' },
+        :environment => env
       )
 
       mod.unmet_dependencies.should == [{
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => ">= 2.2.0",
-        :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/test_gte_req" },
         :mod_details => { :installed_version => "2.0.0" }
       }]
 
@@ -183,13 +182,15 @@ describe Puppet::Module do
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => "v1.0.0",
-        :parent => { :version => "v9.9.9", :name => "puppetlabs/foobaz" },
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/test_specific_req" },
         :mod_details => { :installed_version => "2.0.0" }
       }]
 
     end
 
     it "should consider a dependency without a version requirement to be satisfied" do
+      env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -197,7 +198,8 @@ describe Puppet::Module do
           :dependencies => [{
             "name" => "baz/foobar"
           }]
-        }
+        },
+        :environment => env
       )
       PuppetSpec::Modules.create(
         'foobar',
@@ -205,15 +207,16 @@ describe Puppet::Module do
         :metadata => {
           :version => '2.0.0',
           :author  => 'baz'
-        }
+        },
+        :environment => env
       )
 
       mod.unmet_dependencies.should be_empty
     end
 
     it "should consider a dependency without a semantic version to be unmet" do
-      metadata_file = "#{@modpath}/foobar/metadata.json"
-      Puppet::FileSystem::File.expects(:exist?).with(metadata_file).times(3).returns true
+      env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -221,7 +224,8 @@ describe Puppet::Module do
           :dependencies => [{
             "name" => "baz/foobar"
           }]
-        }
+        },
+        :environment => env
       )
       PuppetSpec::Modules.create(
         'foobar',
@@ -229,7 +233,8 @@ describe Puppet::Module do
         :metadata => {
           :version => '5.1',
           :author  => 'baz'
-        }
+        },
+        :environment => env
       )
 
       mod.unmet_dependencies.should == [{
@@ -254,10 +259,8 @@ describe Puppet::Module do
     end
 
     it "should only list unmet dependencies" do
-      [name, 'satisfied'].each do |mod_name|
-        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
-        Puppet::FileSystem::File.expects(:exist?).with(metadata_file).twice.returns true
-      end
+      env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
       mod = PuppetSpec::Modules.create(
         name,
         @modpath,
@@ -272,7 +275,8 @@ describe Puppet::Module do
               "name" => "baz/notsatisfied"
             }
           ]
-        }
+        },
+        :environment => env
       )
       PuppetSpec::Modules.create(
         'satisfied',
@@ -280,7 +284,8 @@ describe Puppet::Module do
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
-        }
+        },
+        :environment => env
       )
 
       mod.unmet_dependencies.should == [{
@@ -293,6 +298,8 @@ describe Puppet::Module do
     end
 
     it "should be empty when all dependencies are met" do
+      env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
       mod = PuppetSpec::Modules.create(
         'mymod2',
         @modpath,
@@ -307,7 +314,8 @@ describe Puppet::Module do
               "name" => "baz/alsosatisfied"
             }
           ]
-        }
+        },
+        :environment => env
       )
       PuppetSpec::Modules.create(
         'satisfied',
@@ -315,7 +323,8 @@ describe Puppet::Module do
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
-        }
+        },
+        :environment => env
       )
       PuppetSpec::Modules.create(
         'alsosatisfied',
@@ -323,7 +332,8 @@ describe Puppet::Module do
         :metadata => {
           :version => '2.1.0',
           :author  => 'baz'
-        }
+        },
+        :environment => env
       )
 
       mod.unmet_dependencies.should be_empty
@@ -382,31 +392,31 @@ describe Puppet::Module do
     end
     it "should be able to return individual #{filetype}" do
       module_file = File.join(path, dirname, "my/file")
-      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns true
+      Puppet::FileSystem.expects(:exist?).with(module_file).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == module_file
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       module_file = File.join(path, dirname)
-      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns true
+      Puppet::FileSystem.expects(:exist?).with(module_file).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       module_file = File.join(path, dirname)
-      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns false
+      Puppet::FileSystem.expects(:exist?).with(module_file).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       module_file = File.join(path, dirname, "my/file")
-      Puppet::FileSystem::File.expects(:exist?).with(module_file).returns false
+      Puppet::FileSystem.expects(:exist?).with(module_file).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       base = File.join(path, dirname)
-      Puppet::FileSystem::File.expects(:exist?).with(base).returns true
+      Puppet::FileSystem.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
@@ -439,8 +449,8 @@ describe Puppet::Module, "when finding matching manifests" do
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    Puppet::FileSystem::File.expects(:exist?).with("/a/manifests/init.pp").returns(true)
-    Puppet::FileSystem::File.expects(:exist?).with("/a/manifests/init.rb").returns(false)
+    Puppet::FileSystem.expects(:exist?).with("/a/manifests/init.pp").returns(true)
+    Puppet::FileSystem.expects(:exist?).with("/a/manifests/init.rb").returns(false)
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
@@ -492,21 +502,21 @@ describe Puppet::Module do
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
-    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "/*
 +-----------------------------------------------------------------------+
 |                                                                       |
@@ -524,7 +534,7 @@ describe Puppet::Module do
   end
 
   it "should know if it is missing a metadata file" do
-    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns false
+    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
@@ -541,7 +551,7 @@ describe Puppet::Module do
   end
 
   it "should tolerate failure to parse" do
-    Puppet::FileSystem::File.expects(:exist?).with(@module.metadata_file).returns true
+    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
 
     @module.has_metadata?.should be_false
@@ -652,11 +662,13 @@ describe Puppet::Module do
   end
 
   it "should know what other modules require it" do
-    Puppet.settings[:modulepath] = @modpath
+    env = Puppet::Node::Environment.create(:testing, [@modpath], '')
+
     dependable = PuppetSpec::Modules.create(
       'dependable',
       @modpath,
-      :metadata => {:author => 'puppetlabs'}
+      :metadata => {:author => 'puppetlabs'},
+      :environment => env
     )
     PuppetSpec::Modules.create(
       'needy',
@@ -667,7 +679,8 @@ describe Puppet::Module do
             "version_requirement" => ">= 2.2.0",
             "name" => "puppetlabs/dependable"
         }]
-      }
+      },
+      :environment => env
     )
     PuppetSpec::Modules.create(
       'wantit',
@@ -678,7 +691,8 @@ describe Puppet::Module do
             "version_requirement" => "< 5.0.0",
             "name" => "puppetlabs/dependable"
         }]
-      }
+      },
+      :environment => env
     )
     dependable.required_by.should =~ [
       {