diff --git a/acceptance/lib/puppet/acceptance/module_utils.rb b/acceptance/lib/puppet/acceptance/module_utils.rb
index ac67998a8..5b6124998 100644
--- a/acceptance/lib/puppet/acceptance/module_utils.rb
+++ b/acceptance/lib/puppet/acceptance/module_utils.rb
@@ -1,228 +1,282 @@
 module Puppet
   module Acceptance
     module ModuleUtils
 
+      # Return an array of module paths for a given host.
+      #
+      # Example return value:
+      #
+      # [
+      #   "/etc/puppetlabs/puppet/environments/production/modules",
+      #   "/etc/puppetlabs/puppet/modules",
+      #   "/opt/puppet/share/puppet/modules",
+      # ]
+      #
+      # @param host [String] hostname
+      # @return [Array] paths for found modulepath
+      def get_modulepaths_for_host (host)
+        separator = ':'
+        if host['platform'] =~ /windows/
+          separator = ';'
+        end
+        environment = on(host, puppet("config print environment")).stdout.chomp
+        on(host, puppet("config print modulepath --environment #{environment}")).stdout.chomp.split(separator)
+      end
+
+      # Return a string of the default (first) path in modulepath for a given host.
+      #
+      # Example return value:
+      #
+      #   "/etc/puppetlabs/puppet/environments/production/modules"
+      #
+      # @param host [String] hostname
+      # @return [String] first path for found modulepath
+      def get_default_modulepath_for_host (host)
+        get_modulepaths_for_host(host)[0]
+      end
+
       # Return an array of paths to installed modules for a given host.
       #
       # Example return value:
       #
       # [
       #   "/opt/puppet/share/puppet/modules/apt",
       #   "/opt/puppet/share/puppet/modules/auth_conf",
       #   "/opt/puppet/share/puppet/modules/concat",
       # ]
       #
       # @param host [String] hostname
       # @return [Array] paths for found modules
       def get_installed_modules_for_host (host)
         on host, puppet("module list --render-as pson")
         str  = stdout.lines.to_a.last
         pat = /\(([^()]+)\)/
         mods =  str.scan(pat).flatten
         return mods
       end
 
       # Return a hash of array of paths to installed modules for a hosts.
       # The individual hostnames are the keys of the hash. The only value
       # for a given key is an array of paths for the found modules.
       #
       # Example return value:
       #
       # {
       #   "my_master" =>
       #     [
       #       "/opt/puppet/share/puppet/modules/apt",
       #       "/opt/puppet/share/puppet/modules/auth_conf",
       #       "/opt/puppet/share/puppet/modules/concat",
       #     ],
       #   "my_agent01" =>
       #     [
       #       "/opt/puppet/share/puppet/modules/apt",
       #       "/opt/puppet/share/puppet/modules/auth_conf",
       #       "/opt/puppet/share/puppet/modules/concat",
       #     ],
       # }
       #
       # @param hosts [Array] hostnames
       # @return [Hash] paths for found modules indexed by hostname
       def get_installed_modules_for_hosts (hosts)
         mods  = {}
         hosts.each do |host|
           mods[host] = get_installed_modules_for_host host
         end
         return mods
       end
 
       # Compare the module paths in given hashes and remove paths that
       # are were not present in the first hash. The use case for this
       # method is to remove any modules that were installed during the
       # course of a test run.
       #
       # Installed module hashes would be gathered using the
       # `get_+installed_module_for_hosts` command in the setup stage
       # and teardown stages of a test. These hashes would be passed into
       # this method in order to find modules installed during the test
       # and delete them in order to return the SUT environments to their
       # initial state.
       #
       # TODO: Enhance to take versions into account, so that upgrade/
       # downgrade events during a test does not persist in the SUT
       # environment.
       #
       # @param beginning_hash [Hash] paths for found modules indexed
       #   by hostname. Taken in the setup stage of a test.
       # @param ending_hash [Hash] paths for found modules indexed
       #   by hostname. Taken in the teardown stage of a test.
       def rm_installed_modules_from_hosts (beginning_hash, ending_hash)
         ending_hash.each do |host, mod_array|
           mod_array.each do |mod|
             if ! beginning_hash[host].include? mod
-              on host, "rm -rf #{mod}"
+              on host, "rm -rf '#{mod}'"
             end
           end
         end
       end
 
       # Convert a semantic version number string to an integer.
       #
       # Example return value given an input of '1.2.42':
       #
       #   10242
       #
       # @param semver [String] semantic version number
       def semver_to_i ( semver )
         # semver assumed to be in format <major>.<minor>.<patch>
         # calculation assumes that each segment is < 100
         tmp = semver.split('.')
         tmp[0].to_i * 10000 + tmp[1].to_i * 100 + tmp[2].to_i
       end
 
       # Compare two given semantic version numbers.
       #
       # Returns an integer indicating the relationship between the two:
       #   0 indicates that both are equal
       #   a value greater than 0 indicates that the semver1 is greater than semver2
       #   a value less than 0 indicates that the semver1 is less than semver2
       #
       def semver_cmp ( semver1, semver2 )
         semver_to_i(semver1) - semver_to_i(semver2)
       end
 
       # Assert that a module was installed according to the UI..
       #
       # This is a wrapper to centralize the validation about how
       # the UI responded that a module was installed.
       # It is called after a call # to `on ( host )` and inspects
       # STDOUT for specific content.
       #
       # @param stdout [String]
       # @param module_author [String] the author portion of a module name
       # @param module_name [String] the name portion of a module name
       # @param module_verion [String] the version of the module to compare to
       #     installed version
       # @param compare_op [String] the operator for comparing the verions of
       #     the installed module
       def assert_module_installed_ui ( stdout, module_author, module_name, module_version = nil, compare_op = nil )
         valid_compare_ops = {'==' => 'equal to', '>' => 'greater than', '<' => 'less than'}
         assert_match(/#{module_author}-#{module_name}/, stdout,
               "Notice that module '#{module_author}-#{module_name}' was installed was not displayed")
         if version
           /#{module_author}-#{module_name} \(.*v(\d+\.\d+\.\d+)/ =~ stdout
           installed_version = Regexp.last_match[1]
           if valid_compare_ops.include? compare_op
             assert_equal( true, semver_cmp(installed_version, module_version).send(compare_op, 0),
               "Installed version '#{installed_version}' of '#{module_name}' was not #{valid_compare_ops[compare_op]} '#{module_version}'")
           end
         end
       end
 
       # Assert that a module is installed on disk.
       #
       # @param host [HOST] the host object to make the remote call on
-      # @param moduledir [String] the path where the module should be
       # @param module_name [String] the name portion of a module name
-      def assert_module_installed_on_disk ( host, moduledir, module_name )
-        # module directory should exist
-        on host, %Q{[ -d "#{moduledir}/#{module_name}" ]}
+      # @param optional moduledir [String, Array] the path where the module should be, will
+      #        iterate over components of the modulepath by default.
+      def assert_module_installed_on_disk (host, module_name, moduledir=nil)
+        moduledir ||= get_modulepaths_for_host(host)
+        modulepath = moduledir.is_a?(Array) ? moduledir : [moduledir]
+        moduledir= nil
+
+        modulepath.each do |i|
+          # module directory should exist
+          if on(host, %Q{[ -d "#{i}/#{module_name}" ]}, :acceptable_exit_codes => (0..255)).exit_code == 0
+            moduledir = i
+          end
+        end
+        fail_test('module directory not found') unless moduledir
 
         owner = ''
         group = ''
         on host, %Q{ls -ld "#{moduledir}"} do
           listing = stdout.split(' ')
           owner = listing[2]
           group = listing[3]
         end
 
         # A module's files should have:
         #     * a mode of 444 (755, if they're a directory)
         #     * owner == owner of moduledir
         #     * group == group of moduledir
         on host, %Q{ls -alR "#{moduledir}/#{module_name}"} do
           listings = stdout.split("\n")
           listings = listings.grep(/^[bcdlsp-]/)
           listings = listings.reject { |l| l =~ /\.\.$/ }
 
           listings.each do |line|
             assert_match /(drwxr-xr-x|[^d]r--r--r--)[^\d]+\d+\s+#{owner}\s+#{group}/, line,
               "bad permissions for '#{line[/\S+$/]}' - expected 444/755, #{owner}, #{group}"
           end
         end
       end
 
       # Assert that a module is not installed on disk.
       #
       # @param host [HOST] the host object to make the remote call on
-      # @param moduledir [String] the path where the module should be
       # @param module_name [String] the name portion of a module name
-      def assert_module_not_installed_on_disk ( host, moduledir, module_name )
-        on host, %Q{[ ! -d "#{moduledir}/#{module_name}" ]}
+      # @param optional moduledir [String, Array] the path where the module should be, will
+      #        iterate over components of the modulepath by default.
+      def assert_module_not_installed_on_disk (host, module_name, moduledir=nil)
+        moduledir ||= get_modulepaths_for_host(host)
+        modulepath = moduledir.is_a?(Array) ? moduledir : [moduledir]
+        moduledir= nil
+
+        modulepath.each do |i|
+          # module directory should not exist
+          on host, %Q{[ ! -d "#{i}/#{module_name}" ]}
+        end
       end
 
       # Create a simple legacy and directory environment at :path_to_environments.
       #
       # @note Also registers a teardown block to remove generated files.
       #
       # @param path_to_environments [String] directory to contain all the
       #   generated environment files
       # @return [String] path to the new puppet configuration file defining the
       #   environments
       def generate_base_legacy_and_directory_environments(path_to_environments)
         puppet_conf = "#{path_to_environments}/puppet2.conf"
         legacy_env = "#{path_to_environments}/legacyenv"
         dir_envs = "#{path_to_environments}/environments"
 
         step "ensure we don't have left over bad state from another, possibly failed run"
         on master, "rm -rf #{legacy_env} #{dir_envs} #{puppet_conf}"
 
         # and register to clean up afterwords
         teardown do
           on master, "rm -rf #{legacy_env} #{dir_envs} #{puppet_conf}"
         end
 
         step 'Configure a non-default legacy and directory environment'
         apply_manifest_on master, %Q{
           file {
             [
               '#{legacy_env}',
               '#{legacy_env}/modules',
               '#{dir_envs}',
               '#{dir_envs}/direnv',
             ]:
               ensure => directory,
           }
           file {
             '#{puppet_conf}':
               source => $settings::config,
           }
         }
 
+        # remove environmentpath entry from config
+        on master, "sed '/environmentpath/d' #{puppet_conf} > #{path_to_environments}/tmp && mv #{path_to_environments}/tmp #{puppet_conf}"
+
         on master, puppet("config", "set",
                           "modulepath", "#{legacy_env}/modules",
                           "--section", "legacyenv",
                           "--config", puppet_conf)
 
         return puppet_conf
       end
     end
   end
 end
diff --git a/acceptance/tests/config/puppet_manages_own_configuration_in_robust_manner.rb b/acceptance/tests/config/puppet_manages_own_configuration_in_robust_manner.rb
index 543c1d815..ea5bef339 100644
--- a/acceptance/tests/config/puppet_manages_own_configuration_in_robust_manner.rb
+++ b/acceptance/tests/config/puppet_manages_own_configuration_in_robust_manner.rb
@@ -1,82 +1,86 @@
 # User story:
 # A new user has installed puppet either from source or from a gem, which does
 # not put the "puppet" user or group on the system. They run the puppet master,
 # which fails because of the missing user and then correct their actions. They
 # expect that after correcting their actions, puppet will work correctly.
 test_name "Puppet manages its own configuration in a robust manner"
 
 skip_test "JVM Puppet cannot change its user while running." if @options[:is_puppetserver]
 
 # when owner/group works on windows for settings, this confine should be removed.
 confine :except, :platform => 'windows'
 # when managhome roundtrips for solaris, this confine should be removed
 confine :except, :platform => 'solaris'
 # pe setup includes ownership of external directories such as the passenger
 # document root, which puppet itself knows nothing about
 confine :except, :type => 'pe'
 # same issue for a foss passenger run
 if master.is_using_passenger?
   skip_test 'Cannot test with passenger.'
 end
 
 if master.use_service_scripts?
   # Beaker defaults to leaving puppet running when using service scripts,
   # Need to shut it down so we can modify user/group and test startup failure
   on(master, puppet('resource', 'service', master['puppetservice'], 'ensure=stopped'))
 end
 
 step "Clear out yaml directory because of a bug in the indirector/yaml. (See #21145)"
 on master, 'rm -rf $(puppet master --configprint yamldir)'
 
 original_state = {}
 step "Record original state of system users" do
   hosts.each do |host|
     original_state[host] = {}
     original_state[host][:user] = user = host.execute('puppet config print user')
     original_state[host][:group] = group = host.execute('puppet config print group')
     original_state[host][:ug_resources] = on(host, puppet('resource', 'user', user)).stdout
     original_state[host][:ug_resources] += on(host, puppet('resource', 'group', group)).stdout
     original_state[host][:ug_resources] += "Group['#{group}'] -> User['#{user}']\n"
   end
 end
 
 teardown do
   # And cleaning up yaml dir again here because we are changing service
   # user and group ids back to the original uid and gid
   on master, 'rm -rf $(puppet master --configprint yamldir)'
 
+  if master.use_service_scripts?
+    on(master, puppet('resource', 'service', master['puppetservice'], 'ensure=stopped'))
+  end
+
   hosts.each do |host|
-    apply_manifest_on(host, <<-ORIG)
+    apply_manifest_on(host, <<-ORIG, :catch_failures => true)
       #{original_state[host][:ug_resources]}
     ORIG
   end
 
   with_puppet_running_on(master, {}) do
     agents.each do |agent|
       on agent, puppet('agent', '-t', '--server', master)
     end
   end
 end
 
 step "Remove system users" do
   hosts.each do |host|
     on host, puppet('resource', 'user', original_state[host][:user], 'ensure=absent')
     on host, puppet('resource', 'group', original_state[host][:group], 'ensure=absent')
   end
 end
 
 step "Ensure master fails to start when missing system user" do
   on master, puppet('master'), :acceptable_exit_codes => [74] do
     assert_match(/could not change to group "#{original_state[master][:group]}"/, result.output)
     assert_match(/Could not change to user #{original_state[master][:user]}/, result.output)
   end
 end
 
 step "Ensure master starts when making users after having previously failed startup" do
   with_puppet_running_on(master,
                          :master => { :mkusers => true }) do
     agents.each do |agent|
       on agent, puppet('agent', '-t', '--server', master)
     end
   end
 end
diff --git a/acceptance/tests/modules/install/already_installed.rb b/acceptance/tests/modules/install/already_installed.rb
index 203d34ed2..496448154 100644
--- a/acceptance/tests/modules/install/already_installed.rb
+++ b/acceptance/tests/modules/install/already_installed.rb
@@ -1,51 +1,51 @@
 test_name "puppet module install (already installed)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_reference = "#{module_author}-#{module_name}"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step "Setup" do
   stub_forge_on(master)
 end
 
 step "Check that module is not installed" do
-  on master, %Q{[ ! -d "#{master['distmoduledir']}/#{module_name}" ]}
+  assert_module_not_installed_on_disk(master, module_name)
 end
 
 step "Install module" do
   on master, puppet("module install #{module_reference}")
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
 
 step "Try to install a module that is already installed" do
   on master, puppet("module install #{module_reference}"), :acceptable_exit_codes => [0] do
     assert_match(/#{module_reference}.*is already installed/, stdout,
           "Error that module was already installed was not displayed")
   end
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
 
 step "Try to install a specific version of a module that is already installed" do
   on master, puppet("module install #{module_reference} --version 1.x"), :acceptable_exit_codes => [1] do
     assert_match(/Could not install module '#{module_reference}' \(v1.x\)/, stderr,
           "Error that specified module version could not be installed was not displayed")
     assert_match(/#{module_reference}.*is already installed/, stderr,
           "Error that module was already installed was not displayed")
   end
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
 
 step "Install a module that is already installed (with --force)" do
   on master, puppet("module install #{module_reference} --force") do
     assert_module_installed_ui(stdout, module_author, module_name)
   end
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
diff --git a/acceptance/tests/modules/install/already_installed_elsewhere.rb b/acceptance/tests/modules/install/already_installed_elsewhere.rb
index cc7a58dbc..6170dd2b0 100644
--- a/acceptance/tests/modules/install/already_installed_elsewhere.rb
+++ b/acceptance/tests/modules/install/already_installed_elsewhere.rb
@@ -1,64 +1,65 @@
 test_name "puppet module install (already installed elsewhere)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_reference = "#{module_author}-#{module_name}"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 apply_manifest_on master, <<-PP
 file {
   [
-    '#{master['distmoduledir']}',
     '#{master['sitemoduledir']}',
     '#{master['sitemoduledir']}/#{module_name}',
   ]: ensure => directory;
   '#{master['sitemoduledir']}/#{module_name}/metadata.json':
     content => '{
       "name": "#{module_author}/#{module_name}",
       "version": "0.0.1",
       "source": "",
       "author": "#{module_author}",
       "license": "MIT",
       "dependencies": []
     }';
 }
 PP
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 step "Try to install a module that is already installed"
-on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [0] do
+on master, puppet("module install #{module_author}-#{module_name}") do
   assert_match(/#{module_reference}.*is already installed/, stdout,
         "Error that module was already installed was not displayed")
 end
-assert_module_not_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_not_installed_on_disk(master, module_name, default_moduledir)
 
 step "Try to install a specific version of a module that is already installed"
 on master, puppet("module install #{module_author}-#{module_name} --version 1.x"), :acceptable_exit_codes => [1] do
   assert_match(/Could not install module '#{module_author}-#{module_name}' \(v1.x\)/, stderr,
         "Error that specified module version could not be installed was not displayed")
   assert_match(/#{module_author}-#{module_name}.*is already installed/, stderr,
         "Error that module was already installed was not displayed")
 end
-assert_module_not_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_not_installed_on_disk(master, module_name, default_moduledir)
 
 step "Install a specifc module version that is already installed (with --force)"
 on master, puppet("module install #{module_author}-#{module_name} --force --version 0.0.1") do
   assert_module_installed_ui(stdout, module_author, module_name, '0.0.1', '==')
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name, default_moduledir)
 
 step "Install a module that is already installed (with --force)"
 on master, puppet("module install #{module_author}-#{module_name} --force") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name, default_moduledir)
diff --git a/acceptance/tests/modules/install/already_installed_with_local_changes.rb b/acceptance/tests/modules/install/already_installed_with_local_changes.rb
index f173a110e..b043898b8 100644
--- a/acceptance/tests/modules/install/already_installed_with_local_changes.rb
+++ b/acceptance/tests/modules/install/already_installed_with_local_changes.rb
@@ -1,51 +1,51 @@
 test_name "puppet module install (already installed with local changes)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_reference = "#{module_author}-#{module_name}"
-module_path = "#{master['distmoduledir']}/#{module_name}"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup' do
   stub_forge_on(master)
 end
 
 step "Check that module is not installed" do
-  on master, %Q{[ ! -d "#{module_path}" ]}
+  assert_module_not_installed_on_disk(master, module_name)
 end
 
 step "Install module" do
   on master, puppet("module install #{module_reference}")
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
 
 step "Make local changes in installed module" do
+  module_path = "#{get_default_modulepath_for_host(master)}/#{module_name}"
   on master, "echo 'changed' >> #{module_path}/README"
 end
 
 step "Try to install a specific version of a module that is already installed" do
   on master, puppet("module install #{module_reference} --version 1.x"), :acceptable_exit_codes => [1] do
     assert_match(/Could not install module '#{module_reference}' \(v1.x\)/, stderr,
           "Error that specified module version could not be installed was not displayed")
     assert_match(/#{module_reference}.*is already installed/, stderr,
           "Error that module was already installed was not displayed")
     assert_match(/changes made locally/, stderr,
           "Error that module has local changes was not displayed")
   end
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
 end
 
 step "Install a module that is already installed (with --force)" do
   on master, puppet("module install #{module_reference} --force") do
     assert_module_installed_ui(stdout, module_author, module_name)
   end
-  assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+  assert_module_installed_on_disk(master, module_name)
   #validate checksum
 end
diff --git a/acceptance/tests/modules/install/basic_install.rb b/acceptance/tests/modules/install/basic_install.rb
index 98d2aa4c5..719a2724b 100644
--- a/acceptance/tests/modules/install/basic_install.rb
+++ b/acceptance/tests/modules/install/basic_install.rb
@@ -1,25 +1,23 @@
 test_name "puppet module install (agent)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 agents.each do |agent|
   step 'setup'
   stub_forge_on(agent)
 
-  distmoduledir = on(agent, puppet("agent", "--configprint", "confdir")).stdout.chomp + "/modules"
-
   step "install module '#{module_author}-#{module_name}'"
   on(agent, puppet("module install #{module_author}-#{module_name}")) do
     assert_module_installed_ui(stdout, module_author, module_name)
   end
-  assert_module_installed_on_disk(agent, distmoduledir, module_name)
+  assert_module_installed_on_disk(agent, module_name)
 end
diff --git a/acceptance/tests/modules/install/force_ignores_dependencies.rb b/acceptance/tests/modules/install/force_ignores_dependencies.rb
index 2ea57f1d8..f83d19b15 100644
--- a/acceptance/tests/modules/install/force_ignores_dependencies.rb
+++ b/acceptance/tests/modules/install/force_ignores_dependencies.rb
@@ -1,35 +1,35 @@
 test_name "puppet module install (force ignores dependencies)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "git"
 module_dependencies   = ["apache"]
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 step "Try to install an unsatisfiable module"
 on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [1] do
   assert_match(/No version of '#{module_author}-#{module_name}' can satisfy all dependencies/, stderr,
     "Error that module dependencies could not be met was not displayed")
 end
-assert_module_not_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_not_installed_on_disk(master, module_name)
 module_dependencies.each do |dependency|
-  assert_module_not_installed_on_disk(master, master['distmoduledir'], dependency)
+  assert_module_not_installed_on_disk(master, dependency)
 end
 
 step "Install an unsatisfiable module with force"
 on master, puppet("module install #{module_author}-#{module_name} --force") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name)
 module_dependencies.each do |dependency|
-  assert_module_not_installed_on_disk(master, master['distmoduledir'], dependency)
+  assert_module_not_installed_on_disk(master, dependency)
 end
diff --git a/acceptance/tests/modules/install/ignoring_dependencies.rb b/acceptance/tests/modules/install/ignoring_dependencies.rb
index b4603f485..aa1a0082a 100644
--- a/acceptance/tests/modules/install/ignoring_dependencies.rb
+++ b/acceptance/tests/modules/install/ignoring_dependencies.rb
@@ -1,24 +1,24 @@
 test_name "puppet module install (ignoring dependencies)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "java"
 module_dependencies   = ["stdlub"]
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 stub_forge_on(master)
 
 step "Install a module, but ignore dependencies"
 on master, puppet("module install #{module_author}-#{module_name} --ignore-dependencies") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name)
 module_dependencies.each do |dependency|
-  assert_module_not_installed_on_disk(master, master['distmoduledir'], dependency)
+  assert_module_not_installed_on_disk(master, dependency)
 end
diff --git a/acceptance/tests/modules/install/nonexistent_directory.rb b/acceptance/tests/modules/install/nonexistent_directory.rb
index 0822f1dea..3ee753cb9 100644
--- a/acceptance/tests/modules/install/nonexistent_directory.rb
+++ b/acceptance/tests/modules/install/nonexistent_directory.rb
@@ -1,36 +1,37 @@
 test_name "puppet module install (nonexistent directory)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_dependencies = []
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
+  on master, "mv #{default_moduledir}-bak #{default_moduledir}", :acceptable_exit_codes => [0, 1]
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 apply_manifest_on master, <<-PP
   file { '/tmp/modules': ensure => absent, recurse => true, force => true }
 PP
 
 step "Try to install a module to a non-existent directory"
 on master, puppet("module install #{module_author}-#{module_name} --target-dir /tmp/modules") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, '/tmp/modules', module_name)
+assert_module_installed_on_disk(master, module_name, '/tmp/modules')
 
 step "Try to install a module to a non-existent implicit directory"
 # This test relies on destroying the default module directory...
-on master, "mv #{master['distmoduledir']} #{master['distmoduledir']}-bak"
+on master, "mv #{default_moduledir} #{default_moduledir}-bak"
 on master, puppet("module install #{module_author}-#{module_name}") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
-# Restore default module directory...
-on master, "mv #{master['distmoduledir']}-bak #{master['distmoduledir']}"
+assert_module_installed_on_disk(master, module_name, default_moduledir)
diff --git a/acceptance/tests/modules/install/nonexistent_module.rb b/acceptance/tests/modules/install/nonexistent_module.rb
index 736fb9b6a..19b63ef28 100644
--- a/acceptance/tests/modules/install/nonexistent_module.rb
+++ b/acceptance/tests/modules/install/nonexistent_module.rb
@@ -1,42 +1,44 @@
 test_name "puppet module install (nonexistent module)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nonexistent"
 module_dependencies  = []
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 step "Try to install a non-existent module"
 on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [1] do
   assert_match(/could not install '#{module_author}-#{module_name}'/i, stderr,
       "Error that module could not be installed was not displayed")
 
   assert_match(/no releases are available from/i, stderr,
       "Error that no releases were found was not displayed")
 end
 
 step "Try to install a non-existent module (JSON rendering)"
 on master, puppet("module --render-as json install #{module_author}-#{module_name}") do
   require 'json'
   str  = stdout.lines.to_a.last
   json = JSON.parse(str)
 
   oneline_expectation   = /could not install '#{module_author}-#{module_name}'; no releases are available from/i
   multiline_expectation = /could not install '#{module_author}-#{module_name}'.*no releases are available from.*have at least one published release.*\z/im
 
   assert_equal 'failure', json['result']
   assert_equal "#{module_author}-#{module_name}", json['module_name']
   assert_equal '>= 0.0.0', json['module_version']
-  assert_equal master['distmoduledir'], json['install_dir']
+  assert_equal default_moduledir, json['install_dir']
   assert_match oneline_expectation, json['error']['oneline']
   assert_match multiline_expectation, json['error']['multiline']
 end
diff --git a/acceptance/tests/modules/install/with_cycles.rb b/acceptance/tests/modules/install/with_cycles.rb
deleted file mode 100644
index f398397bf..000000000
--- a/acceptance/tests/modules/install/with_cycles.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-test_name "puppet module install (with cycles)"
-require 'puppet/acceptance/module_utils'
-extend Puppet::Acceptance::ModuleUtils
-
-module_author = "pmtacceptance"
-module_name   = "php"
-module_dependencies   = ["apache"]
-
-orig_installed_modules = get_installed_modules_for_hosts hosts
-teardown do
-  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
-end
-
-step 'Setup'
-
-stub_forge_on(master)
-
-# How does this test differ from a with_version test???
-step "Install a module with cycles"
-on master, puppet("module install #{module_author}-#{module_name} --version 0.0.1") do
-  assert_equal <<-OUTPUT, stdout
-\e[mNotice: Preparing to install into #{master['distmoduledir']} ...\e[0m
-\e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
-\e[mNotice: Installing -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
-└─┬ #{module_author}-#{module_name} (\e[0;36mv0.0.1\e[0m)
-  └── #{module_author}-apache (\e[0;36mv0.0.1\e[0m)
-  OUTPUT
-end
-
-# This isn't going to work
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do |res|
-  assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
-├── #{module_author}-apache (\e[0;36mv0.0.1\e[0m)
-└── #{module_author}-#{module_name} (\e[0;36mv0.0.1\e[0m)
-  OUTPUT
-end
diff --git a/acceptance/tests/modules/install/with_dependencies.rb b/acceptance/tests/modules/install/with_dependencies.rb
index 3e177ea3a..e89b3b7f8 100644
--- a/acceptance/tests/modules/install/with_dependencies.rb
+++ b/acceptance/tests/modules/install/with_dependencies.rb
@@ -1,28 +1,28 @@
 test_name "puppet module install (with dependencies)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "java"
 module_dependencies   = ["stdlub"]
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 step "Install a module with dependencies"
 on master, puppet("module install #{module_author}-#{module_name}") do
   assert_module_installed_ui(stdout, module_author, module_name)
   module_dependencies.each do |dependency|
     assert_module_installed_ui(stdout, module_author, dependency)
   end
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name)
 module_dependencies.each do |dependency|
-  assert_module_installed_on_disk(master, master['distmoduledir'], dependency)
+  assert_module_installed_on_disk(master, dependency)
 end
diff --git a/acceptance/tests/modules/install/with_environment.rb b/acceptance/tests/modules/install/with_environment.rb
index 73257713a..fa608f230 100644
--- a/acceptance/tests/modules/install/with_environment.rb
+++ b/acceptance/tests/modules/install/with_environment.rb
@@ -1,70 +1,72 @@
 test_name 'puppet module install (with environment)'
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
+tmpdir = master.tmpdir('environmentpath')
+
 module_author = "pmtacceptance"
 module_name   = "nginx"
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-puppet_conf = generate_base_legacy_and_directory_environments(master['puppetpath'])
+puppet_conf = generate_base_legacy_and_directory_environments(tmpdir)
 
 check_module_install_in = lambda do |environment_path, module_install_args|
   on master, "puppet module install #{module_author}-#{module_name} --config=#{puppet_conf} #{module_install_args}" do
     assert_module_installed_ui(stdout, module_author, module_name)
     assert_match(/#{environment_path}/, stdout,
           "Notice of non default install path was not displayed")
   end
-  assert_module_installed_on_disk(master, "#{environment_path}", module_name)
+  assert_module_installed_on_disk(master, module_name, environment_path)
 end
 
 step 'Install a module into a non default legacy environment' do
-  check_module_install_in.call("#{master['puppetpath']}/legacyenv/modules",
+  check_module_install_in.call("#{tmpdir}/legacyenv/modules",
                                "--environment=legacyenv")
 end
 
 step 'Enable directory environments' do
   on master, puppet("config", "set",
-                    "environmentpath", "#{master['puppetpath']}/environments",
+                    "environmentpath", "#{tmpdir}/environments",
                     "--section", "main",
                     "--config", puppet_conf)
 end
 
 step 'Install a module into a non default directory environment' do
-  check_module_install_in.call("#{master['puppetpath']}/environments/direnv/modules",
+  check_module_install_in.call("#{tmpdir}/environments/direnv/modules",
                               "--environment=direnv")
 end
 
 step 'Prepare a separate modulepath'
 modulepath_dir = master.tmpdir("modulepath")
 apply_manifest_on(master, <<-MANIFEST , :catch_failures => true)
   file {
     [
-      '#{master['puppetpath']}/environments/production',
+      '#{tmpdir}/environments/production',
       '#{modulepath_dir}',
     ]:
 
     ensure => directory,
     owner => #{master['user']},
   }
 MANIFEST
 
 step "Install a module into --modulepath #{modulepath_dir} despite the implicit production directory env existing" do
   check_module_install_in.call(modulepath_dir, "--modulepath=#{modulepath_dir}")
 end
 
 step "Uninstall so we can try a different scenario" do
   on master, "puppet module uninstall #{module_author}-#{module_name} --config=#{puppet_conf} --modulepath=#{modulepath_dir}"
 end
 
 step "Install a module into --modulepath #{modulepath_dir} with a directory env specified" do
   check_module_install_in.call(modulepath_dir,
                                "--modulepath=#{modulepath_dir} --environment=direnv")
 end
diff --git a/acceptance/tests/modules/install/with_existing_module_directory.rb b/acceptance/tests/modules/install/with_existing_module_directory.rb
index dad0212dd..0802a93fb 100644
--- a/acceptance/tests/modules/install/with_existing_module_directory.rb
+++ b/acceptance/tests/modules/install/with_existing_module_directory.rb
@@ -1,76 +1,78 @@
 test_name "puppet module install (with existing module directory)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 apply_manifest_on master, <<-PP
 file {
   [
-    '#{master['distmoduledir']}/#{module_name}',
-    '#{master['distmoduledir']}/apache',
+    '#{default_moduledir}/#{module_name}',
+    '#{default_moduledir}/apache',
   ]: ensure => directory;
-  '#{master['distmoduledir']}/#{module_name}/metadata.json':
+  '#{default_moduledir}/#{module_name}/metadata.json':
     content => '{
       "name": "not#{module_author}/#{module_name}",
       "version": "0.0.3",
       "source": "",
       "author": "not#{module_author}",
       "license": "MIT",
       "dependencies": []
     }';
   [
-    '#{master['distmoduledir']}/#{module_name}/extra.json',
-    '#{master['distmoduledir']}/apache/extra.json',
+    '#{default_moduledir}/#{module_name}/extra.json',
+    '#{default_moduledir}/apache/extra.json',
   ]: content => '';
 }
 PP
 
 step "Try to install a module with a name collision"
 module_name   = "nginx"
 on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [1] do
-  assert_match(/Installation would overwrite #{master['distmoduledir']}\/#{module_name}/, stderr,
+  assert_match(/Installation would overwrite #{default_moduledir}\/#{module_name}/, stderr,
         "Error of module collision was not displayed")
 end
-on master, "[ -f #{master['distmoduledir']}/#{module_name}/extra.json ]"
+on master, "[ -f #{default_moduledir}/#{module_name}/extra.json ]"
 
 step "Try to install a module with a path collision"
 module_name   = "apache"
 on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [1] do
-  assert_match(/Installation would overwrite #{master['distmoduledir']}\/#{module_name}/, stderr,
+  assert_match(/Installation would overwrite #{default_moduledir}\/#{module_name}/, stderr,
         "Error of module collision was not displayed")
 end
-on master, "[ -f #{master['distmoduledir']}/#{module_name}/extra.json ]"
+on master, "[ -f #{default_moduledir}/#{module_name}/extra.json ]"
 
 step "Try to install a module with a dependency that has collides"
 module_name   = "php"
 on master, puppet("module install #{module_author}-#{module_name} --version 0.0.1"), :acceptable_exit_codes => [1] do
   assert_match(/Dependency .* would overwrite/, stderr,
         "Error of dependency collision was not displayed")
 end
-on master, "[ -f #{master['distmoduledir']}/apache/extra.json ]"
+on master, "[ -f #{default_moduledir}/apache/extra.json ]"
 
 step "Install a module with a name collision by using --force"
 module_name   = "nginx"
 on master, puppet("module install #{module_author}-#{module_name} --force"), :acceptable_exit_codes => [0] do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-on master, "[ ! -f #{master['distmoduledir']}/#{module_name}/extra.json ]"
+on master, "[ ! -f #{default_moduledir}/#{module_name}/extra.json ]"
 
 step "Install an module with a name collision by using --force"
 module_name   = "apache"
 on master, puppet("module install #{module_author}-#{module_name} --force"), :acceptable_exit_codes => [0] do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-on master, "[ ! -f #{master['distmoduledir']}/#{module_name}/extra.json ]"
+on master, "[ ! -f #{default_moduledir}/#{module_name}/extra.json ]"
diff --git a/acceptance/tests/modules/install/with_modulepath.rb b/acceptance/tests/modules/install/with_modulepath.rb
index 7c577795d..12c72e2ec 100644
--- a/acceptance/tests/modules/install/with_modulepath.rb
+++ b/acceptance/tests/modules/install/with_modulepath.rb
@@ -1,39 +1,39 @@
 # encoding: UTF-8
 
 test_name "puppet module install (with modulepath)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
   # TODO: make helper take modulepath
   on master, "rm -rf #{master['puppetpath']}/modules2"
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 on master, "mkdir -p #{master['puppetpath']}/modules2"
 
 step "Install a module with relative modulepath"
 on master, "cd #{master['puppetpath']}/modules2 && puppet module install #{module_author}-#{module_name} --modulepath=." do
   assert_module_installed_ui(stdout, module_author, module_name)
   assert_match(/#{master['puppetpath']}\/modules2/, stdout,
         "Notice of non default install path was not displayed")
 end
-assert_module_installed_on_disk(master, "#{master['puppetpath']}/modules2", module_name)
+assert_module_installed_on_disk(master, module_name, "#{master['puppetpath']}/modules2")
 
 step "Install a module with absolute modulepath"
 on master, "test -d #{master['puppetpath']}/modules2/#{module_name} && rm -rf #{master['puppetpath']}/modules2/#{module_name}"
 on master, puppet("module install #{module_author}-#{module_name} --modulepath=#{master['puppetpath']}/modules2") do
   assert_module_installed_ui(stdout, module_author, module_name)
   assert_match(/#{master['puppetpath']}\/modules2/, stdout,
         "Notice of non default install path was not displayed")
 end
-assert_module_installed_on_disk(master, "#{master['puppetpath']}/modules2", module_name)
+assert_module_installed_on_disk(master, module_name, "#{master['puppetpath']}/modules2")
diff --git a/acceptance/tests/modules/install/with_necessary_upgrade.rb b/acceptance/tests/modules/install/with_necessary_upgrade.rb
index aa272f4d6..ff31aa19c 100644
--- a/acceptance/tests/modules/install/with_necessary_upgrade.rb
+++ b/acceptance/tests/modules/install/with_necessary_upgrade.rb
@@ -1,34 +1,36 @@
 test_name "puppet module install (with necessary dependency upgrade)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "java"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 step "Install an older module version"
 module_version = '1.6.0'
 on master, puppet("module install #{module_author}-#{module_name} --version #{module_version}") do
   assert_match(/#{module_author}-#{module_name} \(.*v#{module_version}.*\)/, stdout,
         "Notice of specific version installed was not displayed")
 end
-on master, "grep \"version '#{module_version}'\" #{master['distmoduledir']}/#{module_name}/Modulefile"
+on master, "grep \"version '#{module_version}'\" #{default_moduledir}/#{module_name}/Modulefile"
 
 
 step "Install a module that requires the older module dependency be upgraded"
 on master, puppet("module install #{module_author}-apollo") do
   assert_module_installed_ui(stdout, module_author, module_name, module_version, '>')
 end
 
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_module_installed_ui(stdout, module_author, module_name, module_version, '>')
 end
diff --git a/acceptance/tests/modules/install/with_no_dependencies.rb b/acceptance/tests/modules/install/with_no_dependencies.rb
index f2e73ddb5..b4c7f3e00 100644
--- a/acceptance/tests/modules/install/with_no_dependencies.rb
+++ b/acceptance/tests/modules/install/with_no_dependencies.rb
@@ -1,22 +1,22 @@
 test_name "puppet module install (with no dependencies)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "nginx"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 step "Install a module with no dependencies"
 on master, puppet("module install #{module_author}-#{module_name}") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-assert_module_installed_on_disk(master, master['distmoduledir'], module_name)
+assert_module_installed_on_disk(master, module_name)
diff --git a/acceptance/tests/modules/install/with_unnecessary_upgrade.rb b/acceptance/tests/modules/install/with_unnecessary_upgrade.rb
index c7513b3b7..76449f72c 100644
--- a/acceptance/tests/modules/install/with_unnecessary_upgrade.rb
+++ b/acceptance/tests/modules/install/with_unnecessary_upgrade.rb
@@ -1,36 +1,38 @@
 test_name "puppet module install (with unnecessary dependency upgrade)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "java"
 module_dependencies   = ["stdlub"]
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
+default_moduledir = get_default_modulepath_for_host(master)
+
 stub_forge_on(master)
 
 step "Install an older module version"
 module_version = '1.7.0'
 on master, puppet("module install #{module_author}-#{module_name} --version #{module_version}") do
   assert_match(/#{module_author}-#{module_name} \(.*v#{module_version}.*\)/, stdout,
         "Notice of specific version installed was not displayed")
 end
-on master, "grep \"version '#{module_version}'\" #{master['distmoduledir']}/#{module_name}/Modulefile"
+on master, "grep \"version '#{module_version}'\" #{default_moduledir}/#{module_name}/Modulefile"
 
 
 step "Install a module that depends on a dependency that could be upgraded, but already satisfies constraints"
 module_name   = "apollo"
 on master, puppet("module install #{module_author}-#{module_name}") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
 
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   module_name   = "java"
   assert_module_installed_ui(stdout, module_author, module_name, module_version, '==')
 end
diff --git a/acceptance/tests/modules/install/with_unsatisfied_constraints.rb b/acceptance/tests/modules/install/with_unsatisfied_constraints.rb
index 4e38d1436..456b93fe2 100644
--- a/acceptance/tests/modules/install/with_unsatisfied_constraints.rb
+++ b/acceptance/tests/modules/install/with_unsatisfied_constraints.rb
@@ -1,72 +1,72 @@
 test_name "puppet module install (with unsatisfied constraints)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name   = "git"
 module_reference = "#{module_author}-#{module_name}"
 module_dependencies = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
 apply_manifest_on master, <<-PP
 file {
   [
     '#{master['distmoduledir']}/crakorn',
   ]: ensure => directory;
   '#{master['distmoduledir']}/crakorn/metadata.json':
     content => '{
       "name": "jimmy/crakorn",
       "version": "0.0.1",
       "source": "",
       "author": "jimmy",
       "license": "MIT",
       "dependencies": [
         { "name": "#{module_author}/stdlub", "version_requirement": "1.x" }
       ]
     }';
 }
 PP
 
 step "Try to install a module that has an unsatisfiable dependency"
 on master, puppet("module install #{module_author}-#{module_name}"), :acceptable_exit_codes => [1] do
   assert_match(/No version.*can satisfy all dependencies/, stderr,
         "Unsatisfiable dependency error was not displayed")
   assert_match(/Use `puppet module install --ignore-dependencies/, stderr,
         "Use --ignore-dependencies error was not displayed")
 end
-on master, "[ ! -d #{master['distmoduledir']}/#{module_name} ]"
+assert_module_not_installed_on_disk(master, module_name)
 
 # FIXME I don't understand what behaviour this looking for?
 step "Install the module with an unsatisfiable dependency"
 on master, puppet("module install #{module_author}-#{module_name} --ignore-dependencies") do
   assert_module_installed_ui(stdout, module_author, module_name)
 end
-on master, "[ -d #{master['distmoduledir']}/#{module_name} ]"
+assert_module_installed_on_disk(master, module_name)
 
 step "Try to install a specific version of the unsatisfiable dependency"
 on master, puppet("module install #{module_author}-stdlub --version 1.x"), :acceptable_exit_codes => [1] do
   assert_match(/No version.* can satisfy all dependencies/, stderr,
         "Unsatisfiable dependency was not displayed")
 end
-on master, "[ ! -d #{master['distmoduledir']}/stdlub ]"
+assert_module_not_installed_on_disk(master, 'stdlub')
 
 step "Try to install any version of the unsatisfiable dependency"
 on master, puppet("module install #{module_author}-stdlub"), :acceptable_exit_codes => [1] do
   assert_match(/No version.* can satisfy all dependencies/, stderr,
         "Unsatisfiable dependency was not displayed")
 end
-on master, "[ ! -d #{master['distmoduledir']}/stdlub ]"
+assert_module_not_installed_on_disk(master, 'stdlub')
 
 step "Install the unsatisfiable dependency with --force"
 on master, puppet("module install #{module_author}-stdlub --force") do
   assert_module_installed_ui(stdout, module_author, 'stdlub')
 end
-on master, "[ -d #{master['distmoduledir']}/stdlub ]"
+assert_module_installed_on_disk(master, 'stdlub')
diff --git a/acceptance/tests/modules/install/with_version.rb b/acceptance/tests/modules/install/with_version.rb
index dca9ff281..41c5fdb5b 100644
--- a/acceptance/tests/modules/install/with_version.rb
+++ b/acceptance/tests/modules/install/with_version.rb
@@ -1,31 +1,31 @@
 test_name "puppet module install (with version)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
 module_author = "pmtacceptance"
 module_name = "java"
 module_version = "1.7.0"
 module_dependencies   = []
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 agents.each do |agent|
   step 'setup'
   stub_forge_on(agent)
 
-  distmoduledir = on(agent, puppet("agent", "--configprint", "confdir")).stdout.chomp + "/modules"
-
   step "  install module '#{module_author}-#{module_name}'"
 
+  opts ||= Hash.new
+  opts['ENV']=Command::DEFAULT_GIT_ENV
   command = agent['platform'] =~ /windows/ ?
-    Command.new("cmd.exe /c 'puppet module install --version \"<#{module_version}\" #{module_author}-#{module_name}'") :
+    Command.new("'puppet module install --version \"<#{module_version}\" #{module_author}-#{module_name}'", [], opts) :
     puppet("module install --version \"<#{module_version}\" #{module_author}-#{module_name}")
 
   on(agent, command) do
     assert_module_installed_ui(stdout, module_author, module_name, module_version, '<')
   end
-  assert_module_installed_on_disk(agent, distmoduledir, module_name)
+  assert_module_installed_on_disk(agent, module_name)
 end
diff --git a/acceptance/tests/modules/list/with_environment.rb b/acceptance/tests/modules/list/with_environment.rb
index bbbfed2fc..e57138150 100644
--- a/acceptance/tests/modules/list/with_environment.rb
+++ b/acceptance/tests/modules/list/with_environment.rb
@@ -1,43 +1,45 @@
 test_name 'puppet module list (with environment)'
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
+tmpdir = master.tmpdir('environmentpath')
+
 step 'Setup'
 
 stub_forge_on(master)
 
-puppet_conf = generate_base_legacy_and_directory_environments(master['puppetpath'])
+puppet_conf = generate_base_legacy_and_directory_environments(tmpdir)
 
 install_test_module_in = lambda do |environment|
   on master, puppet("module", "install",
                     "pmtacceptance-nginx",
                     "--config", puppet_conf,
                     "--environment", environment)
 end
 
 check_module_list_in = lambda do |environment, environment_path|
   on master, puppet("module", "list",
                     "--config", puppet_conf,
                     "--environment", environment) do
 
     assert_match(/#{environment_path}/, stdout)
     assert_match(/pmtacceptance-nginx/, stdout)
   end
 end
 
 step 'List modules in a non default legacy environment' do
   install_test_module_in.call('legacyenv')
-  check_module_list_in.call('legacyenv', "#{master['puppetpath']}/legacyenv/modules")
+  check_module_list_in.call('legacyenv', "#{tmpdir}/legacyenv/modules")
 end
 
 step 'Enable directory environments' do
   on master, puppet("config", "set",
-                    "environmentpath", "#{master['puppetpath']}/environments",
+                    "environmentpath", "#{tmpdir}/environments",
                     "--section", "main",
                     "--config", puppet_conf)
 end
 
 step 'List modules in a non default directory environment' do
   install_test_module_in.call('direnv')
-  check_module_list_in.call('direnv', "#{master['puppetpath']}/environments/direnv/modules")
+  check_module_list_in.call('direnv', "#{tmpdir}/environments/direnv/modules")
 end
diff --git a/acceptance/tests/modules/uninstall/with_environment.rb b/acceptance/tests/modules/uninstall/with_environment.rb
index 58228014e..77a682f14 100644
--- a/acceptance/tests/modules/uninstall/with_environment.rb
+++ b/acceptance/tests/modules/uninstall/with_environment.rb
@@ -1,65 +1,67 @@
 test_name 'puppet module uninstall (with environment)'
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
+tmpdir = master.tmpdir('environmentpath')
+
 step 'Setup'
 
 stub_forge_on(master)
 
-puppet_conf = generate_base_legacy_and_directory_environments(master['puppetpath'])
+puppet_conf = generate_base_legacy_and_directory_environments(tmpdir)
 
 crakorn_metadata = <<-EOS
 {
  "name": "jimmy/crakorn",
  "version": "0.4.0",
  "source": "",
  "author": "jimmy",
  "license": "MIT",
  "dependencies": []
 }
 EOS
 
 # Configure a non-default environment
 apply_manifest_on master, %Q{
   file {
     [
-      '#{master['puppetpath']}/legacyenv/modules/crakorn',
-      '#{master['puppetpath']}/environments/direnv/modules',
-      '#{master['puppetpath']}/environments/direnv/modules/crakorn',
+      '#{tmpdir}/legacyenv/modules/crakorn',
+      '#{tmpdir}/environments/direnv/modules',
+      '#{tmpdir}/environments/direnv/modules/crakorn',
     ]:
       ensure => directory,
   }
   file {
-    '#{master['puppetpath']}/legacyenv/modules/crakorn/metadata.json':
+    '#{tmpdir}/legacyenv/modules/crakorn/metadata.json':
       content => '#{crakorn_metadata}',
   }
   file {
-    '#{master['puppetpath']}/environments/direnv/modules/crakorn/metadata.json':
+    '#{tmpdir}/environments/direnv/modules/crakorn/metadata.json':
       content => '#{crakorn_metadata}',
   }
 }
 
 check_module_uninstall_in = lambda do |environment, environment_path|
   on master, "puppet module uninstall jimmy-crakorn --config=#{puppet_conf} --environment=#{environment}" do
     assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to uninstall 'jimmy-crakorn' ...\e[0m
 Removed 'jimmy-crakorn' (\e[0;36mv0.4.0\e[0m) from #{environment_path}
     OUTPUT
   end
   on master, "[ ! -d #{environment_path}/crakorn ]"
 end
 
 step 'Uninstall a module from a non default legacy environment' do
-  check_module_uninstall_in.call('legacyenv', "#{master['puppetpath']}/legacyenv/modules")
+  check_module_uninstall_in.call('legacyenv', "#{tmpdir}/legacyenv/modules")
 end
 
 step 'Enable directory environments' do
   on master, puppet("config", "set",
-                    "environmentpath", "#{master['puppetpath']}/environments",
+                    "environmentpath", "#{tmpdir}/environments",
                     "--section", "main",
                     "--config", puppet_conf)
 end
 
 step 'Uninstall a module from a non default directory environment' do
-  check_module_uninstall_in.call('direnv', "#{master['puppetpath']}/environments/direnv/modules")
+  check_module_uninstall_in.call('direnv', "#{tmpdir}/environments/direnv/modules")
 end
diff --git a/acceptance/tests/modules/uninstall/with_multiple_modules_installed.rb b/acceptance/tests/modules/uninstall/with_multiple_modules_installed.rb
index 2223c9d42..5a56091c7 100644
--- a/acceptance/tests/modules/uninstall/with_multiple_modules_installed.rb
+++ b/acceptance/tests/modules/uninstall/with_multiple_modules_installed.rb
@@ -1,64 +1,68 @@
 test_name "puppet module uninstall (with multiple modules installed)"
 
+if master.is_pe?
+  skip_test
+end
+
 step 'Setup'
 testdir = master.tmpdir('unistallmultiple')
 
 stub_forge_on(master)
 
 teardown do
   on master, "rm -rf #{master['distmoduledir']}/java"
   on master, "rm -rf #{master['distmoduledir']}/stdlub"
 end
 
 on master, "mkdir -p #{testdir}/modules"
 on master, "chown -R #{master['user']}:#{master['group']} #{testdir}"
 
 master_opts = {
   'main' => {
     'modulepath' => "#{testdir}/modules:#{master['sitemoduledir']}:#{master['distmoduledir']}"
   }
 }
 
 with_puppet_running_on master, master_opts, testdir do
   on master, puppet("module install pmtacceptance-java --version 1.6.0 --modulepath #{master['distmoduledir']}")
   on master, puppet("module install pmtacceptance-java --version 1.7.0 --modulepath #{testdir}/modules")
   on master, puppet("module list --modulepath #{master['distmoduledir']}") do
     pattern = Regexp.new([
       "#{master['distmoduledir']}",
       "├── pmtacceptance-java \\(.*v1.6.0.*\\)",
       "└── pmtacceptance-stdlub \\(.*v1.0.0.*\\)"
     ].join("\n"))
     assert_match(pattern, result.output)
   end
 
   on master, puppet("module list --modulepath #{testdir}/modules") do
     pattern = Regexp.new([
       "#{testdir}/modules",
       "├── pmtacceptance-java \\(.*v1.7.0.*\\)",
       "└── pmtacceptance-stdlub \\(.*v1.0.0.*\\)",
     ].join("\n"))
     assert_match(pattern, result.output)
   end
 
   step "Try to uninstall a module that exists multiple locations in the module path"
   on master, puppet("module uninstall pmtacceptance-java"), :acceptable_exit_codes => [1] do
     pattern = Regexp.new([
       ".*Notice: Preparing to uninstall 'pmtacceptance-java' .*",
       ".*Error: Could not uninstall module 'pmtacceptance-java'",
       "  Module 'pmtacceptance-java' appears multiple places in the module path",
       "    'pmtacceptance-java' \\(v1.7.0\\) was found in #{testdir}/modules",
       "    'pmtacceptance-java' \\(v1.6.0\\) was found in #{master['distmoduledir']}",
       "    Use the `--modulepath` option to limit the search to specific directories.*"
     ].join("\n"), Regexp::MULTILINE)
     assert_match(pattern, result.output)
   end
 
   step "Uninstall a module that exists multiple locations by restricting the --modulepath"
   on master, puppet("module uninstall pmtacceptance-java --modulepath #{master['distmoduledir']}") do
     pattern = Regexp.new([
       ".*Notice: Preparing to uninstall 'pmtacceptance-java' .*",
       "Removed 'pmtacceptance-java' \\(.*v1.6.0.*\\) from #{master['distmoduledir']}"
     ].join("\n"), Regexp::MULTILINE)
     assert_match(pattern, result.output)
   end
 end
diff --git a/acceptance/tests/modules/upgrade/in_a_secondary_directory.rb b/acceptance/tests/modules/upgrade/in_a_secondary_directory.rb
index 3b3a79c8a..3b08574b9 100644
--- a/acceptance/tests/modules/upgrade/in_a_secondary_directory.rb
+++ b/acceptance/tests/modules/upgrade/in_a_secondary_directory.rb
@@ -1,32 +1,34 @@
 test_name "puppet module upgrade (in a secondary directory)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlib"
-end
-
 on master, "mkdir -p #{master['distmoduledir']}"
 on master, puppet("module install pmtacceptance-java --version 1.6.0 --target-dir #{master['distmoduledir']}")
 on master, puppet("module list --modulepath #{master['distmoduledir']}") do
   assert_equal <<-OUTPUT, stdout
 #{master['distmoduledir']}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Upgrade a module that has a more recent version published"
 on master, puppet("module upgrade pmtacceptance-java") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
 \e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
 #{master['distmoduledir']}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.1\e[0m)
   OUTPUT
 end
diff --git a/acceptance/tests/modules/upgrade/introducing_new_dependencies.rb b/acceptance/tests/modules/upgrade/introducing_new_dependencies.rb
index 47c3cfdc9..5f4e23d37 100644
--- a/acceptance/tests/modules/upgrade/introducing_new_dependencies.rb
+++ b/acceptance/tests/modules/upgrade/introducing_new_dependencies.rb
@@ -1,37 +1,39 @@
 test_name "puppet module upgrade (introducing new dependencies)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/postql"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-  on master, "rm -rf #{master['distmoduledir']}/geordi"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-stdlub --version 1.0.0")
 on master, puppet("module install pmtacceptance-java --version 1.7.0")
 on master, puppet("module install pmtacceptance-postql --version 0.0.2")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.7.0\e[0m)
 ├── pmtacceptance-postql (\e[0;36mv0.0.2\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Upgrade a module to a version that introduces new dependencies"
 on master, puppet("module upgrade pmtacceptance-postql") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-postql' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-postql' (\e[0;36mv0.0.2\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-postql' (\e[0;36mv0.0.2\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └─┬ pmtacceptance-postql (\e[0;36mv0.0.2 -> v1.0.0\e[0m)
   └── pmtacceptance-geordi (\e[0;36mv0.0.1\e[0m)
   OUTPUT
 end
diff --git a/acceptance/tests/modules/upgrade/not_upgradable.rb b/acceptance/tests/modules/upgrade/not_upgradable.rb
index 679b05f6c..aa503b3d0 100644
--- a/acceptance/tests/modules/upgrade/not_upgradable.rb
+++ b/acceptance/tests/modules/upgrade/not_upgradable.rb
@@ -1,84 +1,86 @@
 test_name "puppet module upgrade (not upgradable)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/unicorns"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-  on master, "rm -rf #{master['distmoduledir']}/nginx"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
-on master, "mkdir -p #{master['distmoduledir']}"
+on master, "mkdir -p #{default_moduledir}"
 apply_manifest_on master, <<-PP
   file {
     [
-      '#{master['distmoduledir']}/nginx',
-      '#{master['distmoduledir']}/unicorns',
+      '#{default_moduledir}/nginx',
+      '#{default_moduledir}/unicorns',
     ]: ensure => directory;
-    '#{master['distmoduledir']}/unicorns/metadata.json':
+    '#{default_moduledir}/unicorns/metadata.json':
       content => '{
         "name": "notpmtacceptance/unicorns",
         "version": "0.0.3",
         "source": "",
         "author": "notpmtacceptance",
         "license": "MIT",
         "dependencies": []
       }';
   }
 PP
 
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── nginx (\e[0;36m???\e[0m)
 ├── notpmtacceptance-unicorns (\e[0;36mv0.0.3\e[0m)
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Try to upgrade a module that is not installed"
 on master, puppet("module upgrade pmtacceptance-nginx"), :acceptable_exit_codes => [1] do
   pattern = Regexp.new([
     %Q{.*Notice: Preparing to upgrade 'pmtacceptance-nginx' .*},
     %Q{.*Error: Could not upgrade module 'pmtacceptance-nginx'},
     %Q{  Module 'pmtacceptance-nginx' is not installed},
     %Q{    Use `puppet module install` to install this module.*},
   ].join("\n"), Regexp::MULTILINE)
   assert_match(pattern, result.output)
 end
 
 # TODO: Determine the appropriate response for this test.
 # step "Try to upgrade a local module"
 # on master, puppet("module upgrade nginx"), :acceptable_exit_codes => [1] do
 #   pattern = Regexp.new([
 #     %Q{.*Notice: Preparing to upgrade 'nginx' .*},
-#     %Q{.*Notice: Found 'nginx' \\(.*\\?\\?\\?.*\\) in #{master['distmoduledir']} .*},
+#     %Q{.*Notice: Found 'nginx' \\(.*\\?\\?\\?.*\\) in #{default_moduledir} .*},
 #     %Q{.*Notice: Downloading from https://forgeapi.puppetlabs.com .*},
 #     %Q{.*Error: Could not upgrade module 'nginx' \\(\\?\\?\\? -> latest\\)},
 #     %Q{  Module 'nginx' does not exist on https://forgeapi.puppetlabs.com.*},
 #   ].join("\n"), Regexp::MULTILINE)
 #   assert_match(pattern, result.output)
 # end
 
 step "Try to upgrade a module that doesn't exist in module_repository"
 on master, puppet("module upgrade notpmtacceptance-unicorns"), :acceptable_exit_codes => [1] do
   assert_match(/could not upgrade 'notpmtacceptance-unicorns'/i, stderr,
     'Could not upgrade error not shown')
 
   assert_match(/no releases are available from/i, stderr,
     'Upgrade failure reason not shown')
 end
 
 step "Try to upgrade an installed module to a version that doesn't exist in module_repository"
 on master, puppet("module upgrade pmtacceptance-java --version 2.0.0"), :acceptable_exit_codes => [1] do
   assert_match(/could not upgrade 'pmtacceptance-java'/i, stderr,
     'Could not upgrade error not shown')
 
   assert_match(/no releases matching '2.0.0' are available from/i, stderr,
     'Upgrade failure reason not shown')
 end
diff --git a/acceptance/tests/modules/upgrade/to_a_specific_version.rb b/acceptance/tests/modules/upgrade/to_a_specific_version.rb
index 301e7dc98..f5af4713a 100644
--- a/acceptance/tests/modules/upgrade/to_a_specific_version.rb
+++ b/acceptance/tests/modules/upgrade/to_a_specific_version.rb
@@ -1,32 +1,35 @@
 test_name "puppet module upgrade (to a specific version)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
-on master, "mkdir -p #{master['distmoduledir']}"
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Upgrade a module to a specific (greater) version"
 on master, puppet("module upgrade pmtacceptance-java --version 1.7.0") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.0\e[0m)
   OUTPUT
 end
diff --git a/acceptance/tests/modules/upgrade/to_installed_version.rb b/acceptance/tests/modules/upgrade/to_installed_version.rb
index d64e2b1e6..02ff8b722 100644
--- a/acceptance/tests/modules/upgrade/to_installed_version.rb
+++ b/acceptance/tests/modules/upgrade/to_installed_version.rb
@@ -1,62 +1,65 @@
 test_name "puppet module upgrade (to installed version)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
-on master, "mkdir -p #{master['distmoduledir']}"
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Try to upgrade a module to the current version"
 on master, puppet("module upgrade pmtacceptance-java --version 1.6.x"), :acceptable_exit_codes => [0] do
   assert_match(/The installed version is already the latest version matching/, stdout,
     "Error that specified version was already satisfied was not displayed")
 end
 
 step "Upgrade a module to the current version with --force"
 on master, puppet("module upgrade pmtacceptance-java --version 1.6.x --force") do
-  assert_match(/#{master['distmoduledir']}/, stdout,
+  assert_match(/#{default_moduledir}/, stdout,
     'Error that distmoduledir was not displayed')
 
   assert_match(/\'pmtacceptance-java\' \(.*v1\.6\.0.*\)/, stdout,
     'Error that package name and version were not displayed')
 end
 
 step "Upgrade to the latest version"
 on master, puppet("module upgrade pmtacceptance-java") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.1\e[0m)
   OUTPUT
 end
 
 step "Try to upgrade a module to the latest version with the latest version installed"
 on master, puppet("module upgrade pmtacceptance-java"), :acceptable_exit_codes => [0] do
   assert_match(/The installed version is already the latest version matching.*latest/, stdout,
     "Error that latest version was already installed was not displayed")
 end
 
 step "Upgrade a module to the latest version with --force"
 on master, puppet("module upgrade pmtacceptance-java --force") do
-  assert_match(/#{master['distmoduledir']}/, stdout,
+  assert_match(/#{default_moduledir}/, stdout,
     'Error that distmoduledir was not displayed')
 
   assert_match(/pmtacceptance-java \(.*v1\.7\.1.*\)/, stdout,
     'Error that package name and version were not displayed')
 end
diff --git a/acceptance/tests/modules/upgrade/with_constraints_on_it.rb b/acceptance/tests/modules/upgrade/with_constraints_on_it.rb
index 4216b8322..32644faaa 100644
--- a/acceptance/tests/modules/upgrade/with_constraints_on_it.rb
+++ b/acceptance/tests/modules/upgrade/with_constraints_on_it.rb
@@ -1,34 +1,37 @@
 test_name "puppet module upgrade (with constraints on it)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/apollo"
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-java --version 1.7.0")
 on master, puppet("module install pmtacceptance-apollo")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-apollo (\e[0;36mv0.0.1\e[0m)
 ├── pmtacceptance-java (\e[0;36mv1.7.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Upgrade a version-constrained module that has an upgrade"
 on master, puppet("module upgrade pmtacceptance-java") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.7.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.7.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.7.0 -> v1.7.1\e[0m)
   OUTPUT
 end
diff --git a/acceptance/tests/modules/upgrade/with_constraints_on_its_dependencies.rb b/acceptance/tests/modules/upgrade/with_constraints_on_its_dependencies.rb
index 07a517301..5fd1ec043 100644
--- a/acceptance/tests/modules/upgrade/with_constraints_on_its_dependencies.rb
+++ b/acceptance/tests/modules/upgrade/with_constraints_on_its_dependencies.rb
@@ -1,80 +1,83 @@
 test_name "puppet module upgrade (with constraints on its dependencies)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/unicorns"
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 apply_manifest_on master, <<-PP
   file {
     [
-      '#{master['distmoduledir']}/unicorns',
+      '#{default_moduledir}/unicorns',
     ]: ensure => directory;
-    '#{master['distmoduledir']}/unicorns/metadata.json':
+    '#{default_moduledir}/unicorns/metadata.json':
       content => '{
         "name": "notpmtacceptance/unicorns",
         "version": "0.0.3",
         "source": "",
         "author": "notpmtacceptance",
         "license": "MIT",
         "dependencies": [
           { "name": "pmtacceptance/stdlub", "version_requirement": "0.0.2" }
         ]
       }';
   }
 PP
 on master, puppet("module install pmtacceptance-stdlub --version 0.0.2")
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── notpmtacceptance-unicorns (\e[0;36mv0.0.3\e[0m)
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv0.0.2\e[0m)
   OUTPUT
 end
 
 step "Try to upgrade a module with constraints on its dependencies that cannot be met"
 on master, puppet("module upgrade pmtacceptance-java --version 1.7.1"), :acceptable_exit_codes => [1] do
   assert_match(/No version.* can satisfy all dependencies/, stderr,
         "Unsatisfiable dependency was not displayed")
 end
 
 step "Relax constraints"
 on master, puppet("module uninstall notpmtacceptance-unicorns")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv0.0.2\e[0m)
   OUTPUT
 end
 
 step "Upgrade a single module, ignoring its dependencies"
 on master, puppet("module upgrade pmtacceptance-java --version 1.7.0 --ignore-dependencies") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.0\e[0m)
   OUTPUT
 end
 
 step "Attempt to upgrade a module where dependency requires upgrade across major version"
 on master, puppet("module upgrade pmtacceptance-java"), :acceptable_exit_codes => [1] do
   assert_match(/There are 1 newer versions/, stderr,
     'Number of newer releases was not displayed')
 
   assert_match(/Dependencies will not be automatically upgraded across major versions/, stderr,
     'Dependency upgrade restriction message was not displayed')
 
   assert_match(/pmtacceptance-stdlub/, stderr,
     'Potential culprit depdendency was not displayed')
 end
diff --git a/acceptance/tests/modules/upgrade/with_environment.rb b/acceptance/tests/modules/upgrade/with_environment.rb
index 2e2a39cb1..3a4aa8c72 100644
--- a/acceptance/tests/modules/upgrade/with_environment.rb
+++ b/acceptance/tests/modules/upgrade/with_environment.rb
@@ -1,49 +1,51 @@
 test_name "puppet module upgrade (with environment)"
 require 'puppet/acceptance/module_utils'
 extend Puppet::Acceptance::ModuleUtils
 
+tmpdir = master.tmpdir('environmentpath')
+
 module_author = "pmtacceptance"
 module_name   = "java"
 module_dependencies = ["stdlub"]
 
 orig_installed_modules = get_installed_modules_for_hosts hosts
 teardown do
   rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
 end
 
 step 'Setup'
 
 stub_forge_on(master)
 
-puppet_conf = generate_base_legacy_and_directory_environments(master['puppetpath'])
+puppet_conf = generate_base_legacy_and_directory_environments(tmpdir)
 
 install_test_module_in = lambda do |environment|
   on master, puppet("module install #{module_author}-#{module_name} --config=#{puppet_conf} --version 1.6.0 --environment=#{environment}") do
     assert_module_installed_ui(stdout, module_author, module_name)
   end
 end
 
 check_module_upgrade_in = lambda do |environment, environment_path|
   on master, puppet("module upgrade #{module_author}-#{module_name} --config=#{puppet_conf} --environment=#{environment}") do
     assert_module_installed_ui(stdout, module_author, module_name)
     on master, "[ -f #{environment_path}/#{module_name}/Modulefile ]"
     on master, "grep 1.7.1 #{environment_path}/#{module_name}/Modulefile"
   end
 end
 
 step "Upgrade a module that has a more recent version published in a legacy environment" do
   install_test_module_in.call('legacyenv')
-  check_module_upgrade_in.call('legacyenv', "#{master['puppetpath']}/legacyenv/modules")
+  check_module_upgrade_in.call('legacyenv', "#{tmpdir}/legacyenv/modules")
 end
 
 step 'Enable directory environments' do
   on master, puppet("config", "set",
-                    "environmentpath", "#{master['puppetpath']}/environments",
+                    "environmentpath", "#{tmpdir}/environments",
                     "--section", "main",
                     "--config", puppet_conf)
 end
 
 step "Upgrade a module that has a more recent version published in a directory environment" do
   install_test_module_in.call('direnv')
-  check_module_upgrade_in.call('direnv', "#{master['puppetpath']}/environments/direnv/modules")
+  check_module_upgrade_in.call('direnv', "#{tmpdir}/environments/direnv/modules")
 end
diff --git a/acceptance/tests/modules/upgrade/with_local_changes.rb b/acceptance/tests/modules/upgrade/with_local_changes.rb
index 4163665a0..f4f930a00 100644
--- a/acceptance/tests/modules/upgrade/with_local_changes.rb
+++ b/acceptance/tests/modules/upgrade/with_local_changes.rb
@@ -1,54 +1,57 @@
 test_name "puppet module upgrade (with local changes)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
-on master, "mkdir -p #{master['distmoduledir']}"
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 apply_manifest_on master, <<-PP
   file {
-    '#{master['distmoduledir']}/java/README': content => "I CHANGE MY READMES";
-    '#{master['distmoduledir']}/java/NEWFILE': content => "I don't exist.'";
+    '#{default_moduledir}/java/README': content => "I CHANGE MY READMES";
+    '#{default_moduledir}/java/NEWFILE': content => "I don't exist.'";
   }
 PP
 
 step "Try to upgrade a module with local changes"
 on master, puppet("module upgrade pmtacceptance-java"), :acceptable_exit_codes => [1] do
   pattern = Regexp.new([
     %Q{.*Notice: Preparing to upgrade 'pmtacceptance-java' ....*},
-    %Q{.*Notice: Found 'pmtacceptance-java' \\(.*v1.6.0.*\\) in #{master['distmoduledir']} ....*},
+    %Q{.*Notice: Found 'pmtacceptance-java' \\(.*v1.6.0.*\\) in #{default_moduledir} ....*},
     %Q{.*Error: Could not upgrade module 'pmtacceptance-java' \\(v1.6.0 -> latest\\)},
     %Q{  Installed module has had changes made locally},
     %Q{    Use `puppet module upgrade --ignore-changes` to upgrade this module anyway.*},
   ].join("\n"), Regexp::MULTILINE)
   assert_match(pattern, result.output)
 end
-on master, %{[[ "$(cat #{master['distmoduledir']}/java/README)" == "I CHANGE MY READMES" ]]}
-on master, "[ -f #{master['distmoduledir']}/java/NEWFILE ]"
+on master, %{[[ "$(cat #{default_moduledir}/java/README)" == "I CHANGE MY READMES" ]]}
+on master, "[ -f #{default_moduledir}/java/NEWFILE ]"
 
 step "Upgrade a module with local changes with --force"
 on master, puppet("module upgrade pmtacceptance-java --force") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.1\e[0m)
   OUTPUT
 end
-on master, %{[[ "$(cat #{master['distmoduledir']}/java/README)" != "I CHANGE MY READMES" ]]}
-on master, "[ ! -f #{master['distmoduledir']}/java/NEWFILE ]"
+on master, %{[[ "$(cat #{default_moduledir}/java/README)" != "I CHANGE MY READMES" ]]}
+on master, "[ ! -f #{default_moduledir}/java/NEWFILE ]"
diff --git a/acceptance/tests/modules/upgrade/with_scattered_dependencies.rb b/acceptance/tests/modules/upgrade/with_scattered_dependencies.rb
index 363721c60..158d544b5 100644
--- a/acceptance/tests/modules/upgrade/with_scattered_dependencies.rb
+++ b/acceptance/tests/modules/upgrade/with_scattered_dependencies.rb
@@ -1,32 +1,34 @@
 test_name "puppet module upgrade (with scattered dependencies)"
 
+skip_test 'needs triage'
+
 step 'Setup'
 
 stub_forge_on(master)
 testdir = master.tmpdir('scattereddeps')
 on master, "mkdir -p #{master['distmoduledir']}"
 on master, "mkdir -p #{master['sitemoduledir']}"
 on master, "mkdir -p #{testdir}/modules"
 
 teardown do
   on master, "rm -rf #{master['distmoduledir']}/java"
   on master, "rm -rf #{master['distmoduledir']}/postql"
 end
 
 master_opts = {
   'main' => {
     'modulepath' => "#{testdir}/modules:#{master['distmoduledir']}:#{master['sitemoduledir']}"
   }
 }
 
 with_puppet_running_on master, master_opts, testdir do
   on master, puppet("module install pmtacceptance-stdlub --version 0.0.2 --target-dir #{testdir}/modules")
   on master, puppet("module install pmtacceptance-java --version 1.6.0 --target-dir #{master['distmoduledir']} --ignore-dependencies")
   on master, puppet("module install pmtacceptance-postql --version 0.0.1 --target-dir #{master['distmoduledir']} --ignore-dependencies")
   on master, puppet("module list") do
     assert_match /pmtacceptance-java.*1\.6\.0/, stdout, 'Could not find pmtacceptance/java'
     assert_match /pmtacceptance-postql.*0\.0\.1/, stdout, 'Could not find pmtacceptance/postql'
     assert_match /pmtacceptance-stdlub.*0\.0\.2/, stdout, 'Could not find pmtacceptance/stdlub'
   end
 
 end
diff --git a/acceptance/tests/modules/upgrade/with_update_available.rb b/acceptance/tests/modules/upgrade/with_update_available.rb
index fd99f267e..3dffd2a8b 100644
--- a/acceptance/tests/modules/upgrade/with_update_available.rb
+++ b/acceptance/tests/modules/upgrade/with_update_available.rb
@@ -1,35 +1,38 @@
 test_name "puppet module upgrade (with update available)"
+require 'puppet/acceptance/module_utils'
+extend Puppet::Acceptance::ModuleUtils
+
+orig_installed_modules = get_installed_modules_for_hosts hosts
+teardown do
+  rm_installed_modules_from_hosts orig_installed_modules, (get_installed_modules_for_hosts hosts)
+end
 
 step 'Setup'
 
 stub_forge_on(master)
-on master, "mkdir -p #{master['distmoduledir']}"
 
-teardown do
-  on master, "rm -rf #{master['distmoduledir']}/java"
-  on master, "rm -rf #{master['distmoduledir']}/stdlub"
-end
+default_moduledir = get_default_modulepath_for_host(master)
 
 on master, puppet("module install pmtacceptance-java --version 1.6.0")
-on master, puppet("module list --modulepath #{master['distmoduledir']}") do
+on master, puppet("module list --modulepath #{default_moduledir}") do
   assert_equal <<-OUTPUT, stdout
-#{master['distmoduledir']}
+#{default_moduledir}
 ├── pmtacceptance-java (\e[0;36mv1.6.0\e[0m)
 └── pmtacceptance-stdlub (\e[0;36mv1.0.0\e[0m)
   OUTPUT
 end
 
 step "Upgrade a module that has a more recent version published"
 on master, puppet("module upgrade pmtacceptance-java") do
   assert_equal <<-OUTPUT, stdout
 \e[mNotice: Preparing to upgrade 'pmtacceptance-java' ...\e[0m
-\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{master['distmoduledir']} ...\e[0m
+\e[mNotice: Found 'pmtacceptance-java' (\e[0;36mv1.6.0\e[m) in #{default_moduledir} ...\e[0m
 \e[mNotice: Downloading from https://forgeapi.puppetlabs.com ...\e[0m
 \e[mNotice: Upgrading -- do not interrupt ...\e[0m
-#{master['distmoduledir']}
+#{default_moduledir}
 └── pmtacceptance-java (\e[0;36mv1.6.0 -> v1.7.1\e[0m)
   OUTPUT
-  on master, "[ -d #{master['distmoduledir']}/java ]"
-  on master, "[ -f #{master['distmoduledir']}/java/Modulefile ]"
-  on master, "grep 1.7.1 #{master['distmoduledir']}/java/Modulefile"
+  on master, "[ -d #{default_moduledir}/java ]"
+  on master, "[ -f #{default_moduledir}/java/Modulefile ]"
+  on master, "grep 1.7.1 #{default_moduledir}/java/Modulefile"
 end
diff --git a/acceptance/tests/resource/host/should_query.rb b/acceptance/tests/resource/host/should_query.rb
deleted file mode 100755
index a01889a9a..000000000
--- a/acceptance/tests/resource/host/should_query.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-test_name "should query hosts out of a hosts file"
-
-agents.each do |agent|
-  file = agent.tmpfile('host-query')
-
-  step "set up the system for the test"
-  on agent, "printf '127.0.0.1 localhost.local localhost\n' > #{file}"
-
-  step "fetch the list of hosts from puppet"
-  on(agent, puppet_resource('host', 'localhost', "target=#{file}")) do
-    found = stdout.scan('present').length
-    fail_test "found #{found} hosts, not 1" if found != 1
-  end
-
-  step "clean up the system"
-  on agent, "rm -f #{file}"
-end