Code smell: Two space indentation

Replaced 106806 occurances of ^( +)(.*$) with

The ruby community almost universally (i.e. everyone but Luke, Markus, and the other eleven people
who learned ruby in the 1900s) uses two-space indentation.

3 Examples:

    The code:
        end

        # Tell getopt which arguments are valid
        def test_get_getopt_args
            element = Setting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
            assert_equal([["--foo", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")

    becomes:
        end

        # Tell getopt which arguments are valid
        def test_get_getopt_args
          element = Setting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
          assert_equal([["--foo", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")

    The code:
            assert_equal(str, val)

            assert_instance_of(Float, result)

        end

        # Now test it with a passed object
    becomes:
          assert_equal(str, val)

          assert_instance_of(Float, result)

        end

        # Now test it with a passed object
    The code:
        end

        assert_nothing_raised do
            klass[:Yay] = "boo"
            klass["Cool"] = :yayness
        end

    becomes:
        end

        assert_nothing_raised do
          klass[:Yay] = "boo"
          klass["Cool"] = :yayness
        end

5 files changed, 1340 insertions, 1340 deletions

diff --git a/test/network/handler/ca.rb b/test/network/handler/ca.rb
index 401b8d5fe..79a1b15dc 100755
--- a/test/network/handler/ca.rb
+++ b/test/network/handler/ca.rb
@@ -9,265 +9,265 @@ require 'mocha'
 $short = (ARGV.length > 0 and ARGV[0] == "short")
 
 class TestCA < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def setup
-        Puppet::Util::SUIDManager.stubs(:asuser).yields
-        super
-    end
-
-    # Verify that we're autosigning.  We have to autosign a "different" machine,
-    # since we always autosign the CA server's certificate.
-    def test_autocertgeneration
-        ca = nil
-
-        # create our ca
-        assert_nothing_raised {
-            ca = Puppet::Network::Handler.ca.new(:autosign => true)
-        }
-
-        # create a cert with a fake name
-        key = nil
-        csr = nil
-        cert = nil
-        hostname = "test.domain.com"
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(
-                :name => "test.domain.com"
-            )
-        }
-
-        # make the request
-        assert_nothing_raised {
-            cert.mkcsr
-        }
-
-        # and get it signed
-        certtext = nil
-        cacerttext = nil
-        assert_nothing_raised {
-            certtext, cacerttext = ca.getcert(cert.csr.to_s)
-        }
-
-        # they should both be strings
-        assert_instance_of(String, certtext)
-        assert_instance_of(String, cacerttext)
-
-        # and they should both be valid certs
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(certtext)
-        }
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(cacerttext)
-        }
-
-        # and pull it again, just to make sure we're getting the same thing
-        newtext = nil
-        assert_nothing_raised {
-            newtext, cacerttext = ca.getcert(
-                cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
-            )
-        }
-
-        assert_equal(certtext,newtext)
-    end
-
-    # this time don't use autosign
-    def test_storeAndSign
-        ca = nil
-        caserv = nil
-
-        # make our CA server
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new(:autosign => false)
-        }
-
-        # retrieve the actual ca object
-        assert_nothing_raised {
-            ca = caserv.ca
-        }
-
-        # make our test cert again
-        key = nil
-        csr = nil
-        cert = nil
-        hostname = "test.domain.com"
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(
-                :name => "anothertest.domain.com"
-            )
-        }
-        # and the CSR
-        assert_nothing_raised {
-            cert.mkcsr
-        }
-
-        # retrieve them
-        certtext = nil
-        assert_nothing_raised {
-            certtext, cacerttext = caserv.getcert(
-                cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
-            )
-        }
-
-        # verify we got nothing back, since autosign is off
-        assert_equal("", certtext)
-
-        # now sign it manually, with the CA object
-        x509 = nil
-        assert_nothing_raised {
-            x509, cacert = ca.sign(cert.csr)
-        }
-
-        # and write it out
-        cert.cert = x509
-        assert_nothing_raised {
-            cert.write
-        }
-
-        assert(File.exists?(cert.certfile))
-
-        # now get them again, and verify that we actually get them
-        newtext = nil
-        assert_nothing_raised {
-            newtext, cacerttext  = caserv.getcert(cert.csr.to_s)
-        }
-
-        assert(newtext)
-        assert_nothing_raised {
-            OpenSSL::X509::Certificate.new(newtext)
-        }
-
-        # Now verify that we can clean a given host's certs
-        assert_nothing_raised {
-            ca.clean("anothertest.domain.com")
-        }
-
-        assert(!File.exists?(cert.certfile), "Cert still exists after clean")
-    end
-
-    # and now test the autosign file
-    def test_autosign
-        autosign = File.join(tmpdir, "autosigntesting")
-        @@tmpfiles << autosign
-        File.open(autosign, "w") { |f|
-            f.puts "hostmatch.domain.com"
-            f.puts "*.other.com"
-        }
-
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new(:autosign => autosign)
-        }
-
-        # make sure we know what's going on
-        assert(caserv.autosign?("hostmatch.domain.com"))
-        assert(caserv.autosign?("fakehost.other.com"))
-        assert(!caserv.autosign?("kirby.reductivelabs.com"))
-        assert(!caserv.autosign?("culain.domain.com"))
-    end
-
-    # verify that things aren't autosigned by default
-    def test_nodefaultautosign
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new
-        }
-
-        # make sure we know what's going on
-        assert(!caserv.autosign?("hostmatch.domain.com"))
-        assert(!caserv.autosign?("fakehost.other.com"))
-        assert(!caserv.autosign?("kirby.reductivelabs.com"))
-        assert(!caserv.autosign?("culain.domain.com"))
-    end
-
-    # We want the CA to autosign its own certificate, because otherwise
-    # the puppetmasterd CA does not autostart.
-    def test_caautosign
-        server = nil
-        Puppet.stubs(:master?).returns true
-        assert_nothing_raised {
-
-                        server = Puppet::Network::HTTPServer::WEBrick.new(
+  include PuppetTest::ServerTest
+
+  def setup
+    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    super
+  end
+
+  # Verify that we're autosigning.  We have to autosign a "different" machine,
+  # since we always autosign the CA server's certificate.
+  def test_autocertgeneration
+    ca = nil
+
+    # create our ca
+    assert_nothing_raised {
+      ca = Puppet::Network::Handler.ca.new(:autosign => true)
+    }
+
+    # create a cert with a fake name
+    key = nil
+    csr = nil
+    cert = nil
+    hostname = "test.domain.com"
+    assert_nothing_raised {
+      cert = Puppet::SSLCertificates::Certificate.new(
+        :name => "test.domain.com"
+      )
+    }
+
+    # make the request
+    assert_nothing_raised {
+      cert.mkcsr
+    }
+
+    # and get it signed
+    certtext = nil
+    cacerttext = nil
+    assert_nothing_raised {
+      certtext, cacerttext = ca.getcert(cert.csr.to_s)
+    }
+
+    # they should both be strings
+    assert_instance_of(String, certtext)
+    assert_instance_of(String, cacerttext)
+
+    # and they should both be valid certs
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(certtext)
+    }
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(cacerttext)
+    }
+
+    # and pull it again, just to make sure we're getting the same thing
+    newtext = nil
+    assert_nothing_raised {
+      newtext, cacerttext = ca.getcert(
+        cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
+      )
+    }
+
+    assert_equal(certtext,newtext)
+  end
+
+  # this time don't use autosign
+  def test_storeAndSign
+    ca = nil
+    caserv = nil
+
+    # make our CA server
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new(:autosign => false)
+    }
+
+    # retrieve the actual ca object
+    assert_nothing_raised {
+      ca = caserv.ca
+    }
+
+    # make our test cert again
+    key = nil
+    csr = nil
+    cert = nil
+    hostname = "test.domain.com"
+    assert_nothing_raised {
+      cert = Puppet::SSLCertificates::Certificate.new(
+        :name => "anothertest.domain.com"
+      )
+    }
+    # and the CSR
+    assert_nothing_raised {
+      cert.mkcsr
+    }
+
+    # retrieve them
+    certtext = nil
+    assert_nothing_raised {
+      certtext, cacerttext = caserv.getcert(
+        cert.csr.to_s, "test.reductivelabs.com", "127.0.0.1"
+      )
+    }
+
+    # verify we got nothing back, since autosign is off
+    assert_equal("", certtext)
+
+    # now sign it manually, with the CA object
+    x509 = nil
+    assert_nothing_raised {
+      x509, cacert = ca.sign(cert.csr)
+    }
+
+    # and write it out
+    cert.cert = x509
+    assert_nothing_raised {
+      cert.write
+    }
+
+    assert(File.exists?(cert.certfile))
+
+    # now get them again, and verify that we actually get them
+    newtext = nil
+    assert_nothing_raised {
+      newtext, cacerttext  = caserv.getcert(cert.csr.to_s)
+    }
+
+    assert(newtext)
+    assert_nothing_raised {
+      OpenSSL::X509::Certificate.new(newtext)
+    }
+
+    # Now verify that we can clean a given host's certs
+    assert_nothing_raised {
+      ca.clean("anothertest.domain.com")
+    }
+
+    assert(!File.exists?(cert.certfile), "Cert still exists after clean")
+  end
+
+  # and now test the autosign file
+  def test_autosign
+    autosign = File.join(tmpdir, "autosigntesting")
+    @@tmpfiles << autosign
+    File.open(autosign, "w") { |f|
+      f.puts "hostmatch.domain.com"
+      f.puts "*.other.com"
+    }
+
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new(:autosign => autosign)
+    }
+
+    # make sure we know what's going on
+    assert(caserv.autosign?("hostmatch.domain.com"))
+    assert(caserv.autosign?("fakehost.other.com"))
+    assert(!caserv.autosign?("kirby.reductivelabs.com"))
+    assert(!caserv.autosign?("culain.domain.com"))
+  end
+
+  # verify that things aren't autosigned by default
+  def test_nodefaultautosign
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new
+    }
+
+    # make sure we know what's going on
+    assert(!caserv.autosign?("hostmatch.domain.com"))
+    assert(!caserv.autosign?("fakehost.other.com"))
+    assert(!caserv.autosign?("kirby.reductivelabs.com"))
+    assert(!caserv.autosign?("culain.domain.com"))
+  end
+
+  # We want the CA to autosign its own certificate, because otherwise
+  # the puppetmasterd CA does not autostart.
+  def test_caautosign
+    server = nil
+    Puppet.stubs(:master?).returns true
+    assert_nothing_raised {
+
+            server = Puppet::Network::HTTPServer::WEBrick.new(
                 
-                :Port => @@port,
+        :Port => @@port,
         
-                :Handlers => {
-                    :CA => {}, # so that certs autogenerate
-                    :Status => nil
-                }
-            )
+        :Handlers => {
+          :CA => {}, # so that certs autogenerate
+          :Status => nil
         }
+      )
+    }
+  end
+
+  # Make sure true/false causes the file to be ignored.
+  def test_autosign_true_beats_file
+    caserv = nil
+    assert_nothing_raised {
+      caserv = Puppet::Network::Handler.ca.new
+    }
+
+    host = "hostname.domain.com"
+
+    # Create an autosign file
+    file = tempfile
+    Puppet[:autosign] = file
+
+    File.open(file, "w") { |f|
+      f.puts host
+    }
+
+    # Start with "false"
+    Puppet[:autosign] = false
+
+    assert(! caserv.autosign?(host), "Host was incorrectly autosigned")
+
+    # Then set it to true
+    Puppet[:autosign] = true
+    assert(caserv.autosign?(host), "Host was not autosigned")
+    # And try a different host
+    assert(caserv.autosign?("other.yay.com"), "Host was not autosigned")
+
+    # And lastly the file
+    Puppet[:autosign] = file
+    assert(caserv.autosign?(host), "Host was not autosigned")
+
+    # And try a different host
+    assert(! caserv.autosign?("other.yay.com"), "Host was autosigned")
+  end
+
+  # Make sure that a CSR created with keys that don't match the existing
+  # cert throws an exception on the server.
+  def test_mismatched_public_keys_throws_exception
+    ca = Puppet::Network::Handler.ca.new
+
+    # First initialize the server
+    client = Puppet::Network::Client.ca.new :CA => ca
+    client.request_cert
+    File.unlink(Puppet[:hostcsr])
+
+    # Now use a different cert name
+    Puppet[:certname] = "my.host.com"
+    client = Puppet::Network::Client.ca.new :CA => ca
+    firstcsr = client.csr
+    File.unlink(Puppet[:hostcsr]) if FileTest.exists?(Puppet[:hostcsr])
+
+    assert_nothing_raised("Could not get cert") do
+      ca.getcert(firstcsr.to_s)
     end
 
-    # Make sure true/false causes the file to be ignored.
-    def test_autosign_true_beats_file
-        caserv = nil
-        assert_nothing_raised {
-            caserv = Puppet::Network::Handler.ca.new
-        }
-
-        host = "hostname.domain.com"
-
-        # Create an autosign file
-        file = tempfile
-        Puppet[:autosign] = file
-
-        File.open(file, "w") { |f|
-            f.puts host
-        }
-
-        # Start with "false"
-        Puppet[:autosign] = false
-
-        assert(! caserv.autosign?(host), "Host was incorrectly autosigned")
-
-        # Then set it to true
-        Puppet[:autosign] = true
-        assert(caserv.autosign?(host), "Host was not autosigned")
-        # And try a different host
-        assert(caserv.autosign?("other.yay.com"), "Host was not autosigned")
-
-        # And lastly the file
-        Puppet[:autosign] = file
-        assert(caserv.autosign?(host), "Host was not autosigned")
-
-        # And try a different host
-        assert(! caserv.autosign?("other.yay.com"), "Host was autosigned")
-    end
-
-    # Make sure that a CSR created with keys that don't match the existing
-    # cert throws an exception on the server.
-    def test_mismatched_public_keys_throws_exception
-        ca = Puppet::Network::Handler.ca.new
-
-        # First initialize the server
-        client = Puppet::Network::Client.ca.new :CA => ca
-        client.request_cert
-        File.unlink(Puppet[:hostcsr])
-
-        # Now use a different cert name
-        Puppet[:certname] = "my.host.com"
-        client = Puppet::Network::Client.ca.new :CA => ca
-        firstcsr = client.csr
-        File.unlink(Puppet[:hostcsr]) if FileTest.exists?(Puppet[:hostcsr])
-
-        assert_nothing_raised("Could not get cert") do
-            ca.getcert(firstcsr.to_s)
-        end
-
-        # Now get rid of the public key, forcing a new csr
-        File.unlink(Puppet[:hostprivkey])
+    # Now get rid of the public key, forcing a new csr
+    File.unlink(Puppet[:hostprivkey])
 
-        client = Puppet::Network::Client.ca.new :CA => ca
+    client = Puppet::Network::Client.ca.new :CA => ca
 
-        second_csr = client.csr
+    second_csr = client.csr
 
-        assert(firstcsr.to_s != second_csr.to_s, "CSR did not change")
+    assert(firstcsr.to_s != second_csr.to_s, "CSR did not change")
 
-        assert_raise(Puppet::Error, "CA allowed mismatched keys") do
-            ca.getcert(second_csr.to_s)
-        end
+    assert_raise(Puppet::Error, "CA allowed mismatched keys") do
+      ca.getcert(second_csr.to_s)
     end
+  end
 end
 
diff --git a/test/network/handler/fileserver.rb b/test/network/handler/fileserver.rb
index bfe76d078..d979821bb 100755
--- a/test/network/handler/fileserver.rb
+++ b/test/network/handler/fileserver.rb
@@ -6,833 +6,833 @@ require 'puppettest'
 require 'puppet/network/handler/fileserver'
 
 class TestFileServer < Test::Unit::TestCase
-    include PuppetTest
-
-    def mkmount(path = nil)
-        mount = nil
-        name = "yaytest"
-        base = path || tempfile
-        Dir.mkdir(base) unless FileTest.exists?(base)
-        # Create a test file
-        File.open(File.join(base, "file"), "w") { |f| f.puts "bazoo" }
-        assert_nothing_raised {
-            mount = Puppet::Network::Handler.fileserver::Mount.new(name, base)
-        }
+  include PuppetTest
+
+  def mkmount(path = nil)
+    mount = nil
+    name = "yaytest"
+    base = path || tempfile
+    Dir.mkdir(base) unless FileTest.exists?(base)
+    # Create a test file
+    File.open(File.join(base, "file"), "w") { |f| f.puts "bazoo" }
+    assert_nothing_raised {
+      mount = Puppet::Network::Handler.fileserver::Mount.new(name, base)
+    }
 
-        mount
-    end
-    # make a simple file source
-    def mktestdir
-        testdir = File.join(tmpdir, "remotefilecopytesting")
-        @@tmpfiles << testdir
-
-        # create a tmpfile
-        pattern = "tmpfile"
-        tmpfile = File.join(testdir, pattern)
-        assert_nothing_raised {
-            Dir.mkdir(testdir)
-            File.open(tmpfile, "w") { |f|
-                3.times { f.puts rand(100) }
-            }
-        }
+    mount
+  end
+  # make a simple file source
+  def mktestdir
+    testdir = File.join(tmpdir, "remotefilecopytesting")
+    @@tmpfiles << testdir
 
-        [testdir, %r{#{pattern}}, tmpfile]
-    end
+    # create a tmpfile
+    pattern = "tmpfile"
+    tmpfile = File.join(testdir, pattern)
+    assert_nothing_raised {
+      Dir.mkdir(testdir)
+      File.open(tmpfile, "w") { |f|
+        3.times { f.puts rand(100) }
+      }
+    }
 
-    # make a bunch of random test files
-    def mktestfiles(testdir)
-        @@tmpfiles << testdir
-        assert_nothing_raised {
-            files = %w{a b c d e}.collect { |l|
-                name = File.join(testdir, "file#{l}")
-                File.open(name, "w") { |f|
-                    f.puts rand(100)
-                }
-
-                name
-            }
+    [testdir, %r{#{pattern}}, tmpfile]
+  end
 
-            return files
+  # make a bunch of random test files
+  def mktestfiles(testdir)
+    @@tmpfiles << testdir
+    assert_nothing_raised {
+      files = %w{a b c d e}.collect { |l|
+        name = File.join(testdir, "file#{l}")
+        File.open(name, "w") { |f|
+          f.puts rand(100)
         }
-    end
 
-    def assert_describe(base, file, server)
-        file = File.basename(file)
-        assert_nothing_raised {
-            desc = server.describe(base + file)
-            assert(desc, "Got no description for #{file}")
-            assert(desc != "", "Got no description for #{file}")
-            assert_match(/^\d+/, desc, "Got invalid description #{desc}")
-        }
-    end
+        name
+      }
 
-    # test for invalid names
-    def test_namefailures
-        server = nil
-        assert_nothing_raised {
+      return files
+    }
+  end
 
-            server = Puppet::Network::Handler.fileserver.new(
+  def assert_describe(base, file, server)
+    file = File.basename(file)
+    assert_nothing_raised {
+      desc = server.describe(base + file)
+      assert(desc, "Got no description for #{file}")
+      assert(desc != "", "Got no description for #{file}")
+      assert_match(/^\d+/, desc, "Got invalid description #{desc}")
+    }
+  end
 
-                :Local => true,
+  # test for invalid names
+  def test_namefailures
+    server = nil
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        [" ", "=" "+", "&", "#", "*"].each do |char|
-            assert_raise(Puppet::Network::Handler::FileServerError, "'#{char}' did not throw a failure in fileserver module names") {
-                server.mount("/tmp", "invalid#{char}name")
-            }
-        end
-    end
+        :Local => true,
 
-    # verify that listing the root behaves as expected
-    def test_listroot
-        server = nil
-        testdir, pattern, tmpfile = mktestdir
+        :Config => false
+      )
+    }
 
-        file = nil
-        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
+    [" ", "=" "+", "&", "#", "*"].each do |char|
+      assert_raise(Puppet::Network::Handler::FileServerError, "'#{char}' did not throw a failure in fileserver module names") {
+        server.mount("/tmp", "invalid#{char}name")
+      }
+    end
+  end
 
-        # and make our fileserver
-        assert_nothing_raised {
+  # verify that listing the root behaves as expected
+  def test_listroot
+    server = nil
+    testdir, pattern, tmpfile = mktestdir
 
-            server = Puppet::Network::Handler.fileserver.new(
+    file = nil
+    checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
-                :Local => true,
+    # and make our fileserver
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        # mount the testdir
-        assert_nothing_raised {
-            server.mount(testdir, "test")
-        }
+        :Local => true,
 
-        # and verify different iterations of 'root' return the same value
-        list = nil
-        assert_nothing_raised {
-            list = server.list("/test/", :manage, true, false)
-        }
+        :Config => false
+      )
+    }
 
-        assert(list =~ pattern)
+    # mount the testdir
+    assert_nothing_raised {
+      server.mount(testdir, "test")
+    }
 
-        assert_nothing_raised {
-            list = server.list("/test", :manage, true, false)
-        }
-        assert(list =~ pattern)
+    # and verify different iterations of 'root' return the same value
+    list = nil
+    assert_nothing_raised {
+      list = server.list("/test/", :manage, true, false)
+    }
 
-    end
+    assert(list =~ pattern)
 
-    # test listing individual files
-    def test_getfilelist
-        server = nil
-        testdir, pattern, tmpfile = mktestdir
+    assert_nothing_raised {
+      list = server.list("/test", :manage, true, false)
+    }
+    assert(list =~ pattern)
 
-        file = nil
+  end
 
-        assert_nothing_raised {
+  # test listing individual files
+  def test_getfilelist
+    server = nil
+    testdir, pattern, tmpfile = mktestdir
 
-            server = Puppet::Network::Handler.fileserver.new(
+    file = nil
 
-                :Local => true,
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        assert_nothing_raised {
-            server.mount(testdir, "test")
-        }
+        :Local => true,
 
-        # get our listing
-        list = nil
-        sfile = "/test/tmpfile"
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false)
-        }
+        :Config => false
+      )
+    }
 
-        output = "/\tfile"
+    assert_nothing_raised {
+      server.mount(testdir, "test")
+    }
 
-        # verify it got listed as a file
-        assert_equal(output, list)
+    # get our listing
+    list = nil
+    sfile = "/test/tmpfile"
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false)
+    }
 
-        # verify we got all fields
-        assert(list !~ /\t\t/)
+    output = "/\tfile"
 
-        # verify that we didn't get the directory itself
-        list.split("\n").each { |line|
-            assert(line !~ %r{remotefile})
-        }
+    # verify it got listed as a file
+    assert_equal(output, list)
 
-        # and then verify that the contents match
-        contents = File.read(tmpfile)
+    # verify we got all fields
+    assert(list !~ /\t\t/)
 
-        ret = nil
-        assert_nothing_raised {
-            ret = server.retrieve(sfile)
-        }
+    # verify that we didn't get the directory itself
+    list.split("\n").each { |line|
+      assert(line !~ %r{remotefile})
+    }
 
-        assert_equal(contents, ret)
-    end
+    # and then verify that the contents match
+    contents = File.read(tmpfile)
 
-    # check that the fileserver is seeing newly created files
-    def test_seenewfiles
-        server = nil
-        testdir, pattern, tmpfile = mktestdir
+    ret = nil
+    assert_nothing_raised {
+      ret = server.retrieve(sfile)
+    }
 
+    assert_equal(contents, ret)
+  end
 
-        newfile = File.join(testdir, "newfile")
+  # check that the fileserver is seeing newly created files
+  def test_seenewfiles
+    server = nil
+    testdir, pattern, tmpfile = mktestdir
 
-        # go through the whole schtick again...
-        file = nil
-        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
-        assert_nothing_raised {
+    newfile = File.join(testdir, "newfile")
 
-            server = Puppet::Network::Handler.fileserver.new(
+    # go through the whole schtick again...
+    file = nil
+    checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
-                :Local => true,
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        assert_nothing_raised {
-            server.mount(testdir, "test")
-        }
+        :Local => true,
 
-        list = nil
-        sfile = "/test/"
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false)
-        }
+        :Config => false
+      )
+    }
 
-        # create the new file
-        File.open(newfile, "w") { |f|
-            3.times { f.puts rand(100) }
-        }
+    assert_nothing_raised {
+      server.mount(testdir, "test")
+    }
 
-        newlist = nil
-        assert_nothing_raised {
-            newlist = server.list(sfile, :manage, true, false)
-        }
+    list = nil
+    sfile = "/test/"
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false)
+    }
 
-        # verify the list has changed
-        assert(list != newlist)
+    # create the new file
+    File.open(newfile, "w") { |f|
+      3.times { f.puts rand(100) }
+    }
 
-        # and verify that we are specifically seeing the new file
-        assert(newlist =~ /newfile/)
-    end
+    newlist = nil
+    assert_nothing_raised {
+      newlist = server.list(sfile, :manage, true, false)
+    }
 
-    # verify we can mount /, which is what local file servers will
-    # normally do
-    def test_mountroot
-        server = nil
-        assert_nothing_raised {
+    # verify the list has changed
+    assert(list != newlist)
 
-            server = Puppet::Network::Handler.fileserver.new(
+    # and verify that we are specifically seeing the new file
+    assert(newlist =~ /newfile/)
+  end
 
-                :Local => true,
+  # verify we can mount /, which is what local file servers will
+  # normally do
+  def test_mountroot
+    server = nil
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        assert_nothing_raised {
-            server.mount("/", "root")
-        }
+        :Local => true,
 
-        testdir, pattern, tmpfile = mktestdir
+        :Config => false
+      )
+    }
 
-        list = nil
-        assert_nothing_raised {
-            list = server.list("/root/#{testdir}", :manage, true, false)
-        }
+    assert_nothing_raised {
+      server.mount("/", "root")
+    }
 
-        assert(list =~ pattern)
-        assert_nothing_raised {
-            list = server.list("/root#{testdir}", :manage, true, false)
-        }
+    testdir, pattern, tmpfile = mktestdir
 
-        assert(list =~ pattern)
-    end
+    list = nil
+    assert_nothing_raised {
+      list = server.list("/root/#{testdir}", :manage, true, false)
+    }
 
-    # verify that we're correctly recursing the right number of levels
-    def test_recursionlevels
-        server = nil
-        assert_nothing_raised {
+    assert(list =~ pattern)
+    assert_nothing_raised {
+      list = server.list("/root#{testdir}", :manage, true, false)
+    }
 
-            server = Puppet::Network::Handler.fileserver.new(
+    assert(list =~ pattern)
+  end
 
-                :Local => true,
+  # verify that we're correctly recursing the right number of levels
+  def test_recursionlevels
+    server = nil
+    assert_nothing_raised {
 
-                :Config => false
-            )
-        }
+      server = Puppet::Network::Handler.fileserver.new(
 
-        # make our deep recursion
-        basedir = File.join(tmpdir, "recurseremotetesting")
-        testdir = "#{basedir}/with/some/sub/directories/for/the/purposes/of/testing"
-        oldfile = File.join(testdir, "oldfile")
-        assert_nothing_raised {
-            system("mkdir -p #{testdir}")
-            File.open(oldfile, "w") { |f|
-                3.times { f.puts rand(100) }
-            }
-            @@tmpfiles << basedir
-        }
+        :Local => true,
 
-        assert_nothing_raised {
-            server.mount(basedir, "test")
-        }
+        :Config => false
+      )
+    }
 
-        # get our list
-        list = nil
-        assert_nothing_raised {
-            list = server.list("/test/with", :manage, false, false)
-        }
+    # make our deep recursion
+    basedir = File.join(tmpdir, "recurseremotetesting")
+    testdir = "#{basedir}/with/some/sub/directories/for/the/purposes/of/testing"
+    oldfile = File.join(testdir, "oldfile")
+    assert_nothing_raised {
+      system("mkdir -p #{testdir}")
+      File.open(oldfile, "w") { |f|
+        3.times { f.puts rand(100) }
+      }
+      @@tmpfiles << basedir
+    }
 
-        # make sure we only got one line, since we're not recursing
-        assert(list !~ /\n/)
+    assert_nothing_raised {
+      server.mount(basedir, "test")
+    }
 
-        # for each level of recursion, make sure we get the right list
-        [0, 1, 2].each { |num|
-            assert_nothing_raised {
-                list = server.list("/test/with", :manage, num, false)
-            }
+    # get our list
+    list = nil
+    assert_nothing_raised {
+      list = server.list("/test/with", :manage, false, false)
+    }
 
-            count = 0
-            while list =~ /\n/
-                list.sub!(/\n/, '')
-                count += 1
-            end
-            assert_equal(num, count)
-        }
-    end
+    # make sure we only got one line, since we're not recursing
+    assert(list !~ /\n/)
+
+    # for each level of recursion, make sure we get the right list
+    [0, 1, 2].each { |num|
+      assert_nothing_raised {
+        list = server.list("/test/with", :manage, num, false)
+      }
+
+      count = 0
+      while list =~ /\n/
+        list.sub!(/\n/, '')
+        count += 1
+      end
+      assert_equal(num, count)
+    }
+  end
 
-    # verify that we're not seeing the dir we ask for; i.e., that our
-    # list is relative to that dir, not it's parent dir
-    def test_listedpath
-        server = nil
-        assert_nothing_raised {
+  # verify that we're not seeing the dir we ask for; i.e., that our
+  # list is relative to that dir, not it's parent dir
+  def test_listedpath
+    server = nil
+    assert_nothing_raised {
 
-            server = Puppet::Network::Handler.fileserver.new(
+      server = Puppet::Network::Handler.fileserver.new(
 
-                :Local => true,
+        :Local => true,
 
-                :Config => false
-            )
-        }
+        :Config => false
+      )
+    }
 
 
-        # create a deep dir
-        basedir = tempfile
-        testdir = "#{basedir}/with/some/sub/directories/for/testing"
-        oldfile = File.join(testdir, "oldfile")
-        assert_nothing_raised {
-            system("mkdir -p #{testdir}")
-            File.open(oldfile, "w") { |f|
-                3.times { f.puts rand(100) }
-            }
-            @@tmpfiles << basedir
-        }
+    # create a deep dir
+    basedir = tempfile
+    testdir = "#{basedir}/with/some/sub/directories/for/testing"
+    oldfile = File.join(testdir, "oldfile")
+    assert_nothing_raised {
+      system("mkdir -p #{testdir}")
+      File.open(oldfile, "w") { |f|
+        3.times { f.puts rand(100) }
+      }
+      @@tmpfiles << basedir
+    }
 
-        # mounty mounty
-        assert_nothing_raised {
-            server.mount(basedir, "localhost")
-        }
+    # mounty mounty
+    assert_nothing_raised {
+      server.mount(basedir, "localhost")
+    }
 
-        list = nil
-        # and then check a few dirs
-        assert_nothing_raised {
-            list = server.list("/localhost/with", :manage, false, false)
-        }
+    list = nil
+    # and then check a few dirs
+    assert_nothing_raised {
+      list = server.list("/localhost/with", :manage, false, false)
+    }
 
-        assert(list !~ /with/)
+    assert(list !~ /with/)
 
-        assert_nothing_raised {
-            list = server.list("/localhost/with/some/sub", :manage, true, false)
-        }
+    assert_nothing_raised {
+      list = server.list("/localhost/with/some/sub", :manage, true, false)
+    }
 
-        assert(list !~ /sub/)
-    end
+    assert(list !~ /sub/)
+  end
 
-    # test many dirs, not necessarily very deep
-    def test_widelists
-        server = nil
-        assert_nothing_raised {
+  # test many dirs, not necessarily very deep
+  def test_widelists
+    server = nil
+    assert_nothing_raised {
 
-            server = Puppet::Network::Handler.fileserver.new(
+      server = Puppet::Network::Handler.fileserver.new(
 
-                :Local => true,
+        :Local => true,
 
-                :Config => false
-            )
-        }
+        :Config => false
+      )
+    }
 
-        basedir = tempfile
-        dirs = %w{a set of directories}
-        assert_nothing_raised {
-            Dir.mkdir(basedir)
-            dirs.each { |dir|
-                Dir.mkdir(File.join(basedir, dir))
-            }
-            @@tmpfiles << basedir
-        }
+    basedir = tempfile
+    dirs = %w{a set of directories}
+    assert_nothing_raised {
+      Dir.mkdir(basedir)
+      dirs.each { |dir|
+        Dir.mkdir(File.join(basedir, dir))
+      }
+      @@tmpfiles << basedir
+    }
 
-        assert_nothing_raised {
-            server.mount(basedir, "localhost")
-        }
+    assert_nothing_raised {
+      server.mount(basedir, "localhost")
+    }
 
-        list = nil
-        assert_nothing_raised {
-            list = server.list("/localhost/", :manage, 1, false)
-        }
-        assert_instance_of(String, list, "Server returned %s instead of string")
-        list = list.split("\n")
+    list = nil
+    assert_nothing_raised {
+      list = server.list("/localhost/", :manage, 1, false)
+    }
+    assert_instance_of(String, list, "Server returned %s instead of string")
+    list = list.split("\n")
 
-        assert_equal(dirs.length + 1, list.length)
-    end
+    assert_equal(dirs.length + 1, list.length)
+  end
 
-    # verify that 'describe' works as advertised
-    def test_describe
-        server = nil
-        testdir = tstdir
-        files = mktestfiles(testdir)
+  # verify that 'describe' works as advertised
+  def test_describe
+    server = nil
+    testdir = tstdir
+    files = mktestfiles(testdir)
 
-        file = nil
-        checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
+    file = nil
+    checks = Puppet::Network::Handler.fileserver::CHECKPARAMS
 
-        assert_nothing_raised {
+    assert_nothing_raised {
 
-            server = Puppet::Network::Handler.fileserver.new(
+      server = Puppet::Network::Handler.fileserver.new(
 
-                :Local => true,
+        :Local => true,
 
-                :Config => false
-            )
-        }
+        :Config => false
+      )
+    }
 
-        assert_nothing_raised {
-            server.mount(testdir, "test")
-        }
+    assert_nothing_raised {
+      server.mount(testdir, "test")
+    }
 
-        # get our list
-        list = nil
-        sfile = "/test/"
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false)
-        }
+    # get our list
+    list = nil
+    sfile = "/test/"
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false)
+    }
 
-        # and describe each file in the list
-        assert_nothing_raised {
-            list.split("\n").each { |line|
-                file, type = line.split("\t")
+    # and describe each file in the list
+    assert_nothing_raised {
+      list.split("\n").each { |line|
+        file, type = line.split("\t")
 
-                desc = server.describe(sfile + file)
-            }
-        }
+        desc = server.describe(sfile + file)
+      }
+    }
 
-        # and then make sure we can describe everything that we know is there
-        files.each { |file|
-            assert_describe(sfile, file, server)
-        }
+    # and then make sure we can describe everything that we know is there
+    files.each { |file|
+      assert_describe(sfile, file, server)
+    }
 
-        # And then describe some files that we know aren't there
-        retval = nil
-        assert_nothing_raised("Describing non-existent files raised an error") {
-            retval = server.describe(sfile + "noexisties")
-        }
+    # And then describe some files that we know aren't there
+    retval = nil
+    assert_nothing_raised("Describing non-existent files raised an error") {
+      retval = server.describe(sfile + "noexisties")
+    }
 
-        assert_equal("", retval, "Description of non-existent files returned a value")
+    assert_equal("", retval, "Description of non-existent files returned a value")
 
-        # Now try to describe some sources that don't even exist
-        retval = nil
+    # Now try to describe some sources that don't even exist
+    retval = nil
 
-            assert_raise(
-                Puppet::Network::Handler::FileServerError,
+      assert_raise(
+        Puppet::Network::Handler::FileServerError,
 
-            "Describing non-existent mount did not raise an error") {
-            retval = server.describe("/notmounted/noexisties")
-        }
+      "Describing non-existent mount did not raise an error") {
+      retval = server.describe("/notmounted/noexisties")
+    }
 
-        assert_nil(retval, "Description of non-existent mounts returned a value")
-    end
+    assert_nil(retval, "Description of non-existent mounts returned a value")
+  end
 
-    def test_describe_does_not_fail_when_mount_does_not_find_file
-        server = Puppet::Network::Handler.fileserver.new(:Local => true, :Config => false)
+  def test_describe_does_not_fail_when_mount_does_not_find_file
+    server = Puppet::Network::Handler.fileserver.new(:Local => true, :Config => false)
 
-        assert_nothing_raised("Failed when describing missing plugins") do
-            server.describe "/plugins"
-        end
+    assert_nothing_raised("Failed when describing missing plugins") do
+      server.describe "/plugins"
     end
+  end
 
-    # test that our config file is parsing and working as planned
-    def test_configfile
-        server = nil
-        basedir = File.join(tmpdir, "fileserverconfigfiletesting")
-        @@tmpfiles << basedir
+  # test that our config file is parsing and working as planned
+  def test_configfile
+    server = nil
+    basedir = File.join(tmpdir, "fileserverconfigfiletesting")
+    @@tmpfiles << basedir
 
-        # make some dirs for mounting
-        Dir.mkdir(basedir)
-        mounts = {}
-        %w{thing thus the-se those}.each { |dir|
-            path = File.join(basedir, dir)
-            Dir.mkdir(path)
-            mounts[dir] = mktestfiles(path)
+    # make some dirs for mounting
+    Dir.mkdir(basedir)
+    mounts = {}
+    %w{thing thus the-se those}.each { |dir|
+      path = File.join(basedir, dir)
+      Dir.mkdir(path)
+      mounts[dir] = mktestfiles(path)
 
-        }
+    }
 
-        # create an example file with each of them
-        conffile = tempfile
-        @@tmpfiles << conffile
+    # create an example file with each of them
+    conffile = tempfile
+    @@tmpfiles << conffile
 
-        File.open(conffile, "w") { |f|
-            f.print "# a test config file
+    File.open(conffile, "w") { |f|
+      f.print "# a test config file
 
 [thing]
-    path #{basedir}/thing
-    allow 192.168.0.*
+  path #{basedir}/thing
+  allow 192.168.0.*
 
 [thus]
-    path #{basedir}/thus
-    allow *.madstop.com, *.kanies.com
-    deny *.sub.madstop.com
+  path #{basedir}/thus
+  allow *.madstop.com, *.kanies.com
+  deny *.sub.madstop.com
 
 [the-se]
-    path #{basedir}/the-se
+  path #{basedir}/the-se
 
 [those]
-    path #{basedir}/those
+  path #{basedir}/those
 
 "
-    }
+  }
 
 
-    # create a server with the file
-    assert_nothing_raised {
+  # create a server with the file
+  assert_nothing_raised {
 
-        server = Puppet::Network::Handler.fileserver.new(
+    server = Puppet::Network::Handler.fileserver.new(
 
-            :Local => false,
+      :Local => false,
 
-            :Config => conffile
-            )
-        }
-
-        list = nil
-        # run through once with no host/ip info, to verify everything is working
-        mounts.each { |mount, files|
-            mount = "/#{mount}/"
-            assert_nothing_raised {
-                list = server.list(mount, :manage, true, false)
-            }
+      :Config => conffile
+      )
+    }
 
-            assert_nothing_raised {
-                list.split("\n").each { |line|
-                    file, type = line.split("\t")
+    list = nil
+    # run through once with no host/ip info, to verify everything is working
+    mounts.each { |mount, files|
+      mount = "/#{mount}/"
+      assert_nothing_raised {
+        list = server.list(mount, :manage, true, false)
+      }
 
-                    desc = server.describe(mount + file)
-                }
-            }
+      assert_nothing_raised {
+        list.split("\n").each { |line|
+          file, type = line.split("\t")
 
-            files.each { |f|
-                assert_describe(mount, f, server)
-            }
+          desc = server.describe(mount + file)
         }
+      }
 
-        # now let's check that things are being correctly forbidden
-        # this is just a map of names and expected results
-        {
-            "thing" => {
-                :deny => [
-                    ["hostname.com", "192.168.1.0"],
-                    ["hostname.com", "192.158.0.0"]
-                ],
-                :allow => [
-                    ["hostname.com", "192.168.0.0"],
-                    ["hostname.com", "192.168.0.245"],
-                ]
-            },
-            "thus" => {
-                :deny => [
-                    ["hostname.com", "192.168.1.0"],
-                    ["name.sub.madstop.com", "192.158.0.0"]
-                ],
-                :allow => [
-                    ["luke.kanies.com", "192.168.0.0"],
-                    ["luke.madstop.com", "192.168.0.245"],
-                ]
+      files.each { |f|
+        assert_describe(mount, f, server)
+      }
+    }
+
+    # now let's check that things are being correctly forbidden
+    # this is just a map of names and expected results
+    {
+      "thing" => {
+        :deny => [
+          ["hostname.com", "192.168.1.0"],
+          ["hostname.com", "192.158.0.0"]
+        ],
+        :allow => [
+          ["hostname.com", "192.168.0.0"],
+          ["hostname.com", "192.168.0.245"],
+        ]
+      },
+      "thus" => {
+        :deny => [
+          ["hostname.com", "192.168.1.0"],
+          ["name.sub.madstop.com", "192.158.0.0"]
+        ],
+        :allow => [
+          ["luke.kanies.com", "192.168.0.0"],
+          ["luke.madstop.com", "192.168.0.245"],
+        ]
+      }
+    }.each { |mount, hash|
+      mount = "/#{mount}/"
+
+      # run through the map
+      hash.each { |type, ary|
+        ary.each { |sub|
+          host, ip = sub
+
+          case type
+          when :deny
+
+            assert_raise(
+              Puppet::AuthorizationError,
+
+              "Host #{host}, ip #{ip}, allowed #{mount}") {
+                list = server.list(mount, :manage, true, false, host, ip)
             }
-        }.each { |mount, hash|
-            mount = "/#{mount}/"
-
-            # run through the map
-            hash.each { |type, ary|
-                ary.each { |sub|
-                    host, ip = sub
-
-                    case type
-                    when :deny
-
-                        assert_raise(
-                            Puppet::AuthorizationError,
-
-                            "Host #{host}, ip #{ip}, allowed #{mount}") {
-                                list = server.list(mount, :manage, true, false, host, ip)
-                        }
-                    when :allow
-                        assert_nothing_raised("Host #{host}, ip #{ip}, denied #{mount}") {
-                            list = server.list(mount, :manage, true, false, host, ip)
-                        }
-                    end
-                }
+          when :allow
+            assert_nothing_raised("Host #{host}, ip #{ip}, denied #{mount}") {
+              list = server.list(mount, :manage, true, false, host, ip)
             }
+          end
         }
+      }
+    }
 
-    end
+  end
 
-    # Test that we smoothly handle invalid config files
-    def test_configfailures
-        # create an example file with each of them
-        conffile = tempfile
+  # Test that we smoothly handle invalid config files
+  def test_configfailures
+    # create an example file with each of them
+    conffile = tempfile
 
-        invalidmounts = {
-            "noexist" => "[noexist]
-    path /this/path/does/not/exist
-    allow 192.168.0.*
+    invalidmounts = {
+      "noexist" => "[noexist]
+  path /this/path/does/not/exist
+  allow 192.168.0.*
 "
 }
 
-    invalidconfigs = [
-        "[not valid]
-    path /this/path/does/not/exist
-    allow 192.168.0.*
+  invalidconfigs = [
+    "[not valid]
+  path /this/path/does/not/exist
+  allow 192.168.0.*
 ",
 "[valid]
-    invalidstatement
-    path /etc
-    allow 192.168.0.*
+  invalidstatement
+  path /etc
+  allow 192.168.0.*
 ",
 "[valid]
-    allow 192.168.0.*
+  allow 192.168.0.*
 "
 ]
 
-    invalidmounts.each { |mount, text|
-        File.open(conffile, "w") { |f|
-            f.print text
-            }
+  invalidmounts.each { |mount, text|
+    File.open(conffile, "w") { |f|
+      f.print text
+      }
 
 
-            # create a server with the file
-            server = nil
-            assert_nothing_raised {
+      # create a server with the file
+      server = nil
+      assert_nothing_raised {
 
-                server = Puppet::Network::Handler.fileserver.new(
+        server = Puppet::Network::Handler.fileserver.new(
 
-                    :Local => true,
+          :Local => true,
 
-                    :Config => conffile
-                )
-            }
+          :Config => conffile
+        )
+      }
 
 
-                assert_raise(
-                    Puppet::Network::Handler::FileServerError,
+        assert_raise(
+          Puppet::Network::Handler::FileServerError,
 
-                    "Invalid mount was mounted") {
-                        server.list(mount, :manage)
-            }
-        }
+          "Invalid mount was mounted") {
+            server.list(mount, :manage)
+      }
+    }
 
-        invalidconfigs.each_with_index { |text, i|
-            File.open(conffile, "w") { |f|
-                f.print text
-            }
+    invalidconfigs.each_with_index { |text, i|
+      File.open(conffile, "w") { |f|
+        f.print text
+      }
 
 
-            # create a server with the file
-            server = nil
+      # create a server with the file
+      server = nil
 
-                assert_raise(
-                    Puppet::Network::Handler::FileServerError,
+        assert_raise(
+          Puppet::Network::Handler::FileServerError,
 
-                    "Invalid config #{i} did not raise error") {
+          "Invalid config #{i} did not raise error") {
 
-                        server = Puppet::Network::Handler.fileserver.new(
+            server = Puppet::Network::Handler.fileserver.new(
 
-                            :Local => true,
+              :Local => true,
 
-                            :Config => conffile
-                )
-            }
-        }
-    end
+              :Config => conffile
+        )
+      }
+    }
+  end
 
-    # verify we reread the config file when it changes
-    def test_filereread
-        server = nil
+  # verify we reread the config file when it changes
+  def test_filereread
+    server = nil
 
-        conffile = tempfile
-        dir = tstdir
+    conffile = tempfile
+    dir = tstdir
 
-        files = mktestfiles(dir)
-        File.open(conffile, "w") { |f|
-            f.print "# a test config file
+    files = mktestfiles(dir)
+    File.open(conffile, "w") { |f|
+      f.print "# a test config file
 
 [thing]
-    path #{dir}
-    allow test1.domain.com
+  path #{dir}
+  allow test1.domain.com
 "
-    }
+  }
 
-    # Reset the timeout, so we reload faster
-    Puppet[:filetimeout] = 0.5
+  # Reset the timeout, so we reload faster
+  Puppet[:filetimeout] = 0.5
 
-    # start our server with a fast timeout
-    assert_nothing_raised {
+  # start our server with a fast timeout
+  assert_nothing_raised {
 
-        server = Puppet::Network::Handler.fileserver.new(
+    server = Puppet::Network::Handler.fileserver.new(
 
-            :Local => false,
+      :Local => false,
 
-            :Config => conffile
-            )
-        }
+      :Config => conffile
+      )
+    }
 
-        list = nil
-        assert_nothing_raised {
+    list = nil
+    assert_nothing_raised {
 
-            list = server.list(
-                "/thing/", :manage, false, false,
+      list = server.list(
+        "/thing/", :manage, false, false,
 
-                "test1.domain.com", "127.0.0.1")
-        }
-        assert(list != "", "List returned nothing in rereard test")
+        "test1.domain.com", "127.0.0.1")
+    }
+    assert(list != "", "List returned nothing in rereard test")
 
-        assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
-            list = server.list("/thing/", :manage, false, false, "test2.domain.com", "127.0.0.1")
-        }
+    assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
+      list = server.list("/thing/", :manage, false, false, "test2.domain.com", "127.0.0.1")
+    }
 
-        sleep 1
-        File.open(conffile, "w") { |f|
-            f.print "# a test config file
+    sleep 1
+    File.open(conffile, "w") { |f|
+      f.print "# a test config file
 
 [thing]
-    path #{dir}
-    allow test2.domain.com
+  path #{dir}
+  allow test2.domain.com
 "
+  }
+
+  assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
+    list = server.list("/thing/", :manage, false, false, "test1.domain.com", "127.0.0.1")
     }
 
-    assert_raise(Puppet::AuthorizationError, "List allowed invalid host") {
-        list = server.list("/thing/", :manage, false, false, "test1.domain.com", "127.0.0.1")
-        }
+    assert_nothing_raised {
+      list = server.list("/thing/", :manage, false, false, "test2.domain.com", "127.0.0.1")
+    }
 
-        assert_nothing_raised {
-            list = server.list("/thing/", :manage, false, false, "test2.domain.com", "127.0.0.1")
-        }
+    assert(list != "", "List returned nothing in rereard test")
 
-        assert(list != "", "List returned nothing in rereard test")
+    list = nil
+  end
 
-        list = nil
-    end
+  # Verify that we get converted to the right kind of string
+  def test_mountstring
+    mount = nil
+    name = "yaytest"
+    path = tmpdir
+    assert_nothing_raised {
+      mount = Puppet::Network::Handler.fileserver::Mount.new(name, path)
+    }
 
-    # Verify that we get converted to the right kind of string
-    def test_mountstring
-        mount = nil
-        name = "yaytest"
-        path = tmpdir
-        assert_nothing_raised {
-            mount = Puppet::Network::Handler.fileserver::Mount.new(name, path)
-        }
+    assert_equal("mount[#{name}]", mount.to_s)
+  end
 
-        assert_equal("mount[#{name}]", mount.to_s)
-    end
+  def test_servinglinks
+    # Disable the checking, so changes propagate immediately.
+    Puppet[:filetimeout] = -5
+    server = nil
+    source = tempfile
+    file = File.join(source, "file")
+    link = File.join(source, "link")
+    Dir.mkdir(source)
+    File.open(file, "w") { |f| f.puts "yay" }
+    File.symlink(file, link)
+    assert_nothing_raised {
 
-    def test_servinglinks
-        # Disable the checking, so changes propagate immediately.
-        Puppet[:filetimeout] = -5
-        server = nil
-        source = tempfile
-        file = File.join(source, "file")
-        link = File.join(source, "link")
-        Dir.mkdir(source)
-        File.open(file, "w") { |f| f.puts "yay" }
-        File.symlink(file, link)
-        assert_nothing_raised {
+      server = Puppet::Network::Handler.fileserver.new(
 
-            server = Puppet::Network::Handler.fileserver.new(
+        :Local => true,
 
-                :Local => true,
+        :Config => false
+      )
+    }
 
-                :Config => false
-            )
-        }
+    assert_nothing_raised {
+      server.mount(source, "mount")
+    }
 
-        assert_nothing_raised {
-            server.mount(source, "mount")
-        }
+    # First describe the link when following
+    results = {}
+    assert_nothing_raised {
+      server.describe("/mount/link", :follow).split("\t").zip(
+        Puppet::Network::Handler.fileserver::CHECKPARAMS
+      ).each { |v,p| results[p] = v }
+    }
 
-        # First describe the link when following
-        results = {}
-        assert_nothing_raised {
-            server.describe("/mount/link", :follow).split("\t").zip(
-                Puppet::Network::Handler.fileserver::CHECKPARAMS
-            ).each { |v,p| results[p] = v }
-        }
+    assert_equal("file", results[:type])
 
-        assert_equal("file", results[:type])
+    # Then not
+    results = {}
+    assert_nothing_raised {
+      server.describe("/mount/link", :manage).split("\t").zip(
+        Puppet::Network::Handler.fileserver::CHECKPARAMS
+      ).each { |v,p| results[p] = v }
+    }
 
-        # Then not
-        results = {}
-        assert_nothing_raised {
-            server.describe("/mount/link", :manage).split("\t").zip(
-                Puppet::Network::Handler.fileserver::CHECKPARAMS
-            ).each { |v,p| results[p] = v }
-        }
+    assert_equal("link", results[:type])
 
-        assert_equal("link", results[:type])
+    results.each { |p,v|
+      assert(v, "#{p} has no value")
+      assert(v != "", "#{p} has no value")
+    }
+  end
+
+  # Test that substitution patterns in the path are exapanded
+  # properly.  Disabled, because it was testing too much of the process
+  # and in a non-portable way.  This is a thorough enough test that it should
+  # be kept, but it should be done in a way that is clearly portable (e.g.,
+  # no md5 sums of file paths).
+  def test_host_specific
+    client1 = "client1.example.com"
+    client2 = "client2.example.com"
+    ip = "127.0.0.1"
+
+    # Setup a directory hierarchy for the tests
+    fsdir = File.join(tmpdir, "host-specific")
+    @@tmpfiles << fsdir
+    hostdir = File.join(fsdir, "host")
+    fqdndir = File.join(fsdir, "fqdn")
+    client1_hostdir = File.join(hostdir, "client1")
+    client2_fqdndir = File.join(fqdndir, client2)
+    contents = {
+      client1_hostdir => "client1\n",
+      client2_fqdndir => client2 + "\n"
+    }
+    [fsdir, hostdir, fqdndir, client1_hostdir, client2_fqdndir].each { |d|  Dir.mkdir(d) }
 
-        results.each { |p,v|
-            assert(v, "#{p} has no value")
-            assert(v != "", "#{p} has no value")
-        }
+    [client1_hostdir, client2_fqdndir].each do |d|
+      File.open(File.join(d, "file.txt"), "w") do |f|
+        f.print contents[d]
+      end
     end
-
-    # Test that substitution patterns in the path are exapanded
-    # properly.  Disabled, because it was testing too much of the process
-    # and in a non-portable way.  This is a thorough enough test that it should
-    # be kept, but it should be done in a way that is clearly portable (e.g.,
-    # no md5 sums of file paths).
-    def test_host_specific
-        client1 = "client1.example.com"
-        client2 = "client2.example.com"
-        ip = "127.0.0.1"
-
-        # Setup a directory hierarchy for the tests
-        fsdir = File.join(tmpdir, "host-specific")
-        @@tmpfiles << fsdir
-        hostdir = File.join(fsdir, "host")
-        fqdndir = File.join(fsdir, "fqdn")
-        client1_hostdir = File.join(hostdir, "client1")
-        client2_fqdndir = File.join(fqdndir, client2)
-        contents = {
-            client1_hostdir => "client1\n",
-            client2_fqdndir => client2 + "\n"
-        }
-        [fsdir, hostdir, fqdndir, client1_hostdir, client2_fqdndir].each { |d|  Dir.mkdir(d) }
-
-        [client1_hostdir, client2_fqdndir].each do |d|
-            File.open(File.join(d, "file.txt"), "w") do |f|
-                f.print contents[d]
-            end
-        end
-        conffile = tempfile
-        File.open(conffile, "w") do |f|
-            f.print("
+    conffile = tempfile
+    File.open(conffile, "w") do |f|
+      f.print("
 [host]
 path #{hostdir}/%h
 allow *
@@ -840,421 +840,421 @@ allow *
 path #{fqdndir}/%H
 allow *
 ")
-    end
+  end
 
-    server = nil
-    assert_nothing_raised {
+  server = nil
+  assert_nothing_raised {
 
-        server = Puppet::Network::Handler.fileserver.new(
+    server = Puppet::Network::Handler.fileserver.new(
 
-            :Local => true,
+      :Local => true,
 
-            :Config => conffile
-            )
-        }
+      :Config => conffile
+      )
+    }
 
-        # check that list returns the correct thing for the two clients
-        list = nil
-        sfile = "/host/file.txt"
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false, client1, ip)
-        }
-        assert_equal("/\tfile", list)
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false, client2, ip)
-        }
-        assert_equal("", list)
+    # check that list returns the correct thing for the two clients
+    list = nil
+    sfile = "/host/file.txt"
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false, client1, ip)
+    }
+    assert_equal("/\tfile", list)
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false, client2, ip)
+    }
+    assert_equal("", list)
 
-        sfile = "/fqdn/file.txt"
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false, client1, ip)
-        }
-        assert_equal("", list)
-        assert_nothing_raised {
-            list = server.list(sfile, :manage, true, false, client2, ip)
-        }
-        assert_equal("/\tfile", list)
+    sfile = "/fqdn/file.txt"
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false, client1, ip)
+    }
+    assert_equal("", list)
+    assert_nothing_raised {
+      list = server.list(sfile, :manage, true, false, client2, ip)
+    }
+    assert_equal("/\tfile", list)
 
-        # check describe
-        sfile = "/host/file.txt"
-        assert_nothing_raised {
-            list = server.describe(sfile, :manage, client1, ip).split("\t")
-        }
-        assert_equal(5, list.size)
-        assert_equal("file", list[1])
-        md5 = Digest::MD5.hexdigest(contents[client1_hostdir])
-        assert_equal("{md5}#{md5}", list[4])
+    # check describe
+    sfile = "/host/file.txt"
+    assert_nothing_raised {
+      list = server.describe(sfile, :manage, client1, ip).split("\t")
+    }
+    assert_equal(5, list.size)
+    assert_equal("file", list[1])
+    md5 = Digest::MD5.hexdigest(contents[client1_hostdir])
+    assert_equal("{md5}#{md5}", list[4])
 
-        assert_nothing_raised {
-            list = server.describe(sfile, :manage, client2, ip).split("\t")
-        }
-        assert_equal([], list)
+    assert_nothing_raised {
+      list = server.describe(sfile, :manage, client2, ip).split("\t")
+    }
+    assert_equal([], list)
 
-        sfile = "/fqdn/file.txt"
-        assert_nothing_raised {
-            list = server.describe(sfile, :manage, client1, ip).split("\t")
-        }
-        assert_equal([], list)
+    sfile = "/fqdn/file.txt"
+    assert_nothing_raised {
+      list = server.describe(sfile, :manage, client1, ip).split("\t")
+    }
+    assert_equal([], list)
 
-        assert_nothing_raised {
-            list = server.describe(sfile, :manage, client2, ip).split("\t")
-        }
-        assert_equal(5, list.size)
-        assert_equal("file", list[1])
-        md5 = Digest::MD5.hexdigest(contents[client2_fqdndir])
-        assert_equal("{md5}#{md5}", list[4])
-
-        # Check retrieve
-        sfile = "/host/file.txt"
-        assert_nothing_raised {
-            list = server.retrieve(sfile, :manage, client1, ip).chomp
-        }
-        assert_equal(contents[client1_hostdir].chomp, list)
+    assert_nothing_raised {
+      list = server.describe(sfile, :manage, client2, ip).split("\t")
+    }
+    assert_equal(5, list.size)
+    assert_equal("file", list[1])
+    md5 = Digest::MD5.hexdigest(contents[client2_fqdndir])
+    assert_equal("{md5}#{md5}", list[4])
 
-        assert_nothing_raised {
-            list = server.retrieve(sfile, :manage, client2, ip).chomp
-        }
-        assert_equal("", list)
+    # Check retrieve
+    sfile = "/host/file.txt"
+    assert_nothing_raised {
+      list = server.retrieve(sfile, :manage, client1, ip).chomp
+    }
+    assert_equal(contents[client1_hostdir].chomp, list)
 
-        sfile = "/fqdn/file.txt"
-        assert_nothing_raised {
-            list = server.retrieve(sfile, :manage, client1, ip).chomp
-        }
-        assert_equal("", list)
+    assert_nothing_raised {
+      list = server.retrieve(sfile, :manage, client2, ip).chomp
+    }
+    assert_equal("", list)
 
-        assert_nothing_raised {
-            list = server.retrieve(sfile, :manage, client2, ip).chomp
-        }
-        assert_equal(contents[client2_fqdndir].chomp, list)
-    end
+    sfile = "/fqdn/file.txt"
+    assert_nothing_raised {
+      list = server.retrieve(sfile, :manage, client1, ip).chomp
+    }
+    assert_equal("", list)
 
-    # Make sure the 'subdir' method in Mount works.
-    def test_mount_subdir
-        mount = nil
-        base = tempfile
-        Dir.mkdir(base)
-        subdir = File.join(base, "subdir")
-        Dir.mkdir(subdir)
-        [base, subdir].each do |d|
-            File.open(File.join(d, "file"), "w") { |f| f.puts "bazoo" }
-        end
-        mount = mkmount(base)
-
-        assert_equal(base, mount.subdir, "Did not default to base path")
-        assert_equal(subdir, mount.subdir("subdir"), "Did not default to base path")
+    assert_nothing_raised {
+      list = server.retrieve(sfile, :manage, client2, ip).chomp
+    }
+    assert_equal(contents[client2_fqdndir].chomp, list)
+  end
+
+  # Make sure the 'subdir' method in Mount works.
+  def test_mount_subdir
+    mount = nil
+    base = tempfile
+    Dir.mkdir(base)
+    subdir = File.join(base, "subdir")
+    Dir.mkdir(subdir)
+    [base, subdir].each do |d|
+      File.open(File.join(d, "file"), "w") { |f| f.puts "bazoo" }
     end
+    mount = mkmount(base)
 
-    # Make sure mounts get correctly marked expandable or not, depending on
-    # the path.
-    def test_expandable
-        name = "yaytest"
-        dir = tempfile
-        Dir.mkdir(dir)
+    assert_equal(base, mount.subdir, "Did not default to base path")
+    assert_equal(subdir, mount.subdir("subdir"), "Did not default to base path")
+  end
 
-        mount = mkmount
-        assert_nothing_raised {
-            mount.path = dir
-        }
+  # Make sure mounts get correctly marked expandable or not, depending on
+  # the path.
+  def test_expandable
+    name = "yaytest"
+    dir = tempfile
+    Dir.mkdir(dir)
 
-        assert(! mount.expandable?, "Mount incorrectly called expandable")
+    mount = mkmount
+    assert_nothing_raised {
+      mount.path = dir
+    }
 
-        assert_nothing_raised {
-            mount.path = "/dir/a%a"
-        }
-        assert(mount.expandable?, "Mount not called expandable")
+    assert(! mount.expandable?, "Mount incorrectly called expandable")
 
-        # This isn't a valid replacement pattern, so it should throw an error
-        # because the dir doesn't exist
-        assert_raise(Puppet::Network::Handler::FileServerError) {
-            mount.path = "/dir/a%"
-        }
+    assert_nothing_raised {
+      mount.path = "/dir/a%a"
+    }
+    assert(mount.expandable?, "Mount not called expandable")
 
-        # Now send it back to a normal path
-        assert_nothing_raised {
-            mount.path = dir
-        }
-        # Make sure it got reverted
-        assert(! mount.expandable?, "Mount incorrectly called expandable")
+    # This isn't a valid replacement pattern, so it should throw an error
+    # because the dir doesn't exist
+    assert_raise(Puppet::Network::Handler::FileServerError) {
+      mount.path = "/dir/a%"
+    }
 
+    # Now send it back to a normal path
+    assert_nothing_raised {
+      mount.path = dir
+    }
+    # Make sure it got reverted
+    assert(! mount.expandable?, "Mount incorrectly called expandable")
 
-    end
 
-    def test_mount_expand
-        mount = mkmount
-
-        check = proc do |client, pattern, repl|
-            path = "/my/#{pattern}/file"
-            assert_equal("/my/#{repl}/file", mount.expand(path, client))
-        end
-
-        # Do a round of checks with a fake client
-        client = "host.domain.com"
-        {"%h" => "host", # Short name
-        "%H" => client, # Full name
-        "%d" => "domain.com", # domain
-        "%%" => "%", # escape
-        "%o" => "%o" # other
-        }.each do |pat, repl|
-            result = check.call(client, pat, repl)
-        end
-
-        # Now, check that they use Facter info
-        client = nil
-        Facter.stubs(:value).with { |v| v.to_s == "hostname" }.returns("myhost")
-        Facter.stubs(:value).with { |v| v.to_s == "domain" }.returns("mydomain.com")
-
-
-            Facter.stubs(:to_hash).returns(
-                {
-                    :ipaddress => "127.0.0.1",
-                    :hostname => "myhost",
-                    :domain   => "mydomain.com",
-
-        })
-
-
-        {"%h" => "myhost", # Short name
-        "%H" => "myhost.mydomain.com", # Full name
-        "%d" => "mydomain.com", # domain
-        "%%" => "%", # escape
-        "%o" => "%o" # other
-        }.each do |pat, repl|
-            check.call(client, pat, repl)
-        end
+  end
 
-    end
+  def test_mount_expand
+    mount = mkmount
 
-    # Test that the fileserver expands the %h and %d things.
-    def test_fileserver_expansion
-        server = nil
-        assert_nothing_raised {
+    check = proc do |client, pattern, repl|
+      path = "/my/#{pattern}/file"
+      assert_equal("/my/#{repl}/file", mount.expand(path, client))
+    end
 
-            server = Puppet::Network::Handler.fileserver.new(
+    # Do a round of checks with a fake client
+    client = "host.domain.com"
+    {"%h" => "host", # Short name
+    "%H" => client, # Full name
+    "%d" => "domain.com", # domain
+    "%%" => "%", # escape
+    "%o" => "%o" # other
+    }.each do |pat, repl|
+      result = check.call(client, pat, repl)
+    end
 
-                :Local => true,
+    # Now, check that they use Facter info
+    client = nil
+    Facter.stubs(:value).with { |v| v.to_s == "hostname" }.returns("myhost")
+    Facter.stubs(:value).with { |v| v.to_s == "domain" }.returns("mydomain.com")
 
-                :Config => false
-            )
-        }
 
-        dir = tempfile
+      Facter.stubs(:to_hash).returns(
+        {
+          :ipaddress => "127.0.0.1",
+          :hostname => "myhost",
+          :domain   => "mydomain.com",
 
-        # When mocks attack, part 2
-        kernel_fact = Facter.value(:kernel)
+    })
 
-        ip = '127.0.0.1'
 
+    {"%h" => "myhost", # Short name
+    "%H" => "myhost.mydomain.com", # Full name
+    "%d" => "mydomain.com", # domain
+    "%%" => "%", # escape
+    "%o" => "%o" # other
+    }.each do |pat, repl|
+      check.call(client, pat, repl)
+    end
 
-            Facter.stubs(:to_hash).returns(
-                {
-                    :kernel => kernel_fact,
-                    :ipaddress => "127.0.0.1",
-                    :hostname => "myhost",
-                    :domain   => "mydomain.com",
+  end
 
-        })
+  # Test that the fileserver expands the %h and %d things.
+  def test_fileserver_expansion
+    server = nil
+    assert_nothing_raised {
 
-        Dir.mkdir(dir)
-        host = "myhost.mydomain.com"
-        {
-            "%H" => "myhost.mydomain.com", "%h" => "myhost", "%d" => "mydomain.com"
-        }.each do |pattern, string|
-            file = File.join(dir, string)
-            mount = File.join(dir, pattern)
-            File.open(file, "w") do |f| f.puts "yayness: #{string}" end
-            name = "name"
-            obj = nil
-            assert_nothing_raised {
-                obj = server.mount(mount, name)
-            }
-            obj.allow "*"
+      server = Puppet::Network::Handler.fileserver.new(
 
-            ret = nil
-            assert_nothing_raised do
-                ret = server.list("/name", :manage, false, false, host, ip)
-            end
+        :Local => true,
 
-            assert_equal("/\tfile", ret)
+        :Config => false
+      )
+    }
 
-            assert_nothing_raised do
-                ret = server.describe("/name", :manage, host, ip)
-            end
-            assert(ret =~ /\tfile\t/, "Did not get valid a description (#{ret.inspect})")
+    dir = tempfile
 
-            assert_nothing_raised do
-                ret = server.retrieve("/name", :manage, host, ip)
-            end
+    # When mocks attack, part 2
+    kernel_fact = Facter.value(:kernel)
 
-            assert_equal(ret, File.read(file))
+    ip = '127.0.0.1'
 
-            server.umount(name)
 
-            File.unlink(file)
-        end
+      Facter.stubs(:to_hash).returns(
+        {
+          :kernel => kernel_fact,
+          :ipaddress => "127.0.0.1",
+          :hostname => "myhost",
+          :domain   => "mydomain.com",
+
+    })
+
+    Dir.mkdir(dir)
+    host = "myhost.mydomain.com"
+    {
+      "%H" => "myhost.mydomain.com", "%h" => "myhost", "%d" => "mydomain.com"
+    }.each do |pattern, string|
+      file = File.join(dir, string)
+      mount = File.join(dir, pattern)
+      File.open(file, "w") do |f| f.puts "yayness: #{string}" end
+      name = "name"
+      obj = nil
+      assert_nothing_raised {
+        obj = server.mount(mount, name)
+      }
+      obj.allow "*"
+
+      ret = nil
+      assert_nothing_raised do
+        ret = server.list("/name", :manage, false, false, host, ip)
+      end
+
+      assert_equal("/\tfile", ret)
+
+      assert_nothing_raised do
+        ret = server.describe("/name", :manage, host, ip)
+      end
+      assert(ret =~ /\tfile\t/, "Did not get valid a description (#{ret.inspect})")
+
+      assert_nothing_raised do
+        ret = server.retrieve("/name", :manage, host, ip)
+      end
+
+      assert_equal(ret, File.read(file))
+
+      server.umount(name)
+
+      File.unlink(file)
     end
+  end
+
+  # Test the default modules fileserving
+  def test_modules_default
+    moddir = tempfile
+    Dir.mkdir(moddir)
+    mounts = {}
+    Puppet[:modulepath] = moddir
+
+    mods = %w{green red}.collect do |name|
+      path = File::join(moddir, name, Puppet::Module::FILES)
+      FileUtils::mkdir_p(path)
+      if name == "green"
+        file = File::join(path, "test.txt")
+        File::open(file, "w") { |f| f.print name }
+      end
 
-    # Test the default modules fileserving
-    def test_modules_default
-        moddir = tempfile
-        Dir.mkdir(moddir)
-        mounts = {}
-        Puppet[:modulepath] = moddir
-
-        mods = %w{green red}.collect do |name|
-            path = File::join(moddir, name, Puppet::Module::FILES)
-            FileUtils::mkdir_p(path)
-            if name == "green"
-                file = File::join(path, "test.txt")
-                File::open(file, "w") { |f| f.print name }
-            end
-
-            Puppet::Module::find(name)
-        end
+      Puppet::Module::find(name)
+    end
 
-        conffile = tempfile
+    conffile = tempfile
 
-        File.open(conffile, "w") { |f| f.puts "# a test config file" }
+    File.open(conffile, "w") { |f| f.puts "# a test config file" }
 
-        # create a server with the file
-        server = nil
-        assert_nothing_raised {
+    # create a server with the file
+    server = nil
+    assert_nothing_raised {
 
-            server = Puppet::Network::Handler::FileServer.new(
+      server = Puppet::Network::Handler::FileServer.new(
 
-                :Local => false ,
+        :Local => false ,
 
-                :Config => conffile
-            )
-        }
+        :Config => conffile
+      )
+    }
 
-        mods.each do |mod|
-            mount = "/#{mod.name}/"
-            list = nil
-            assert_nothing_raised {
-                list = server.list(mount, :manage, true, false)
-            }
-            list = list.split("\n")
-            if mod.name == "green"
-                assert_equal(2, list.size)
-                assert_equal("/\tdirectory", list[0])
-                assert_equal("/test.txt\tfile", list[1])
-            else
-                assert_equal(1, list.size)
-                assert_equal("/\tdirectory", list[0])
-            end
-
-            assert_nothing_raised("Host 'allow' denied #{mount}") {
-                server.list(mount, :manage, true, false, 'allow.example.com', "192.168.0.1")
-            }
-        end
+    mods.each do |mod|
+      mount = "/#{mod.name}/"
+      list = nil
+      assert_nothing_raised {
+        list = server.list(mount, :manage, true, false)
+      }
+      list = list.split("\n")
+      if mod.name == "green"
+        assert_equal(2, list.size)
+        assert_equal("/\tdirectory", list[0])
+        assert_equal("/test.txt\tfile", list[1])
+      else
+        assert_equal(1, list.size)
+        assert_equal("/\tdirectory", list[0])
+      end
+
+      assert_nothing_raised("Host 'allow' denied #{mount}") {
+        server.list(mount, :manage, true, false, 'allow.example.com', "192.168.0.1")
+      }
     end
+  end
 
-    # Test that configuring deny/allow for modules works
-    def test_modules_config
-        moddir = tempfile
-        Dir.mkdir(moddir)
-        mounts = {}
-        Puppet[:modulepath] = moddir
+  # Test that configuring deny/allow for modules works
+  def test_modules_config
+    moddir = tempfile
+    Dir.mkdir(moddir)
+    mounts = {}
+    Puppet[:modulepath] = moddir
 
-        path = File::join(moddir, "amod", Puppet::Module::FILES)
-        file = File::join(path, "test.txt")
-        FileUtils::mkdir_p(path)
-        File::open(file, "w") { |f| f.print "Howdy" }
+    path = File::join(moddir, "amod", Puppet::Module::FILES)
+    file = File::join(path, "test.txt")
+    FileUtils::mkdir_p(path)
+    File::open(file, "w") { |f| f.print "Howdy" }
 
-        mod = Puppet::Module::find("amod")
+    mod = Puppet::Module::find("amod")
 
-        conffile = tempfile
-        @@tmpfiles << conffile
+    conffile = tempfile
+    @@tmpfiles << conffile
 
-        File.open(conffile, "w") { |f|
-            f.print "# a test config file
+    File.open(conffile, "w") { |f|
+      f.print "# a test config file
 [modules]
-    path #{basedir}/thing
-    allow 192.168.0.*
+  path #{basedir}/thing
+  allow 192.168.0.*
 "
-    }
+  }
 
-    # create a server with the file
-    server = nil
-    assert_nothing_raised {
+  # create a server with the file
+  server = nil
+  assert_nothing_raised {
 
-        server = Puppet::Network::Handler::FileServer.new(
+    server = Puppet::Network::Handler::FileServer.new(
 
-            :Local => false,
+      :Local => false,
 
-            :Config => conffile
-            )
-        }
+      :Config => conffile
+      )
+    }
 
-        list = nil
-        mount = "/#{mod.name}/"
-        assert_nothing_raised {
-            list = server.list(mount, :manage, true, false)
-        }
+    list = nil
+    mount = "/#{mod.name}/"
+    assert_nothing_raised {
+      list = server.list(mount, :manage, true, false)
+    }
 
-        assert_nothing_raised {
-            list.split("\n").each { |line|
-                file, type = line.split("\t")
-                server.describe(mount + file)
-            }
-        }
+    assert_nothing_raised {
+      list.split("\n").each { |line|
+        file, type = line.split("\t")
+        server.describe(mount + file)
+      }
+    }
 
-        assert_describe(mount, file, server)
+    assert_describe(mount, file, server)
 
-        # now let's check that things are being correctly forbidden
+    # now let's check that things are being correctly forbidden
 
-            assert_raise(
-                Puppet::AuthorizationError,
+      assert_raise(
+        Puppet::AuthorizationError,
 
-                    "Host 'deny' allowed #{mount}") {
-                        server.list(mount, :manage, true, false, 'deny.example.com', "192.168.1.1")
-        }
-        assert_nothing_raised("Host 'allow' denied #{mount}") {
-            server.list(mount, :manage, true, false, 'allow.example.com', "192.168.0.1")
-        }
-    end
+          "Host 'deny' allowed #{mount}") {
+            server.list(mount, :manage, true, false, 'deny.example.com', "192.168.1.1")
+    }
+    assert_nothing_raised("Host 'allow' denied #{mount}") {
+      server.list(mount, :manage, true, false, 'allow.example.com', "192.168.0.1")
+    }
+  end
 
-    # Make sure we successfully throw errors -- someone ran into this with
-    # 0.22.4.
-    def test_failures
-        # create a server with the file
-        server = nil
+  # Make sure we successfully throw errors -- someone ran into this with
+  # 0.22.4.
+  def test_failures
+    # create a server with the file
+    server = nil
 
-        config = tempfile
-        [
-        "[this is invalid]\nallow one.two.com", # invalid name
-        "[valid]\nallow *.testing something.com", # invalid allow
-        "[valid]\nallow one.two.com\ndeny *.testing something.com", # invalid deny
-        ].each do |failer|
-            File.open(config, "w") { |f| f.puts failer }
-            assert_raise(Puppet::Network::Handler::FileServerError, "Did not fail on #{failer.inspect}") {
+    config = tempfile
+    [
+    "[this is invalid]\nallow one.two.com", # invalid name
+    "[valid]\nallow *.testing something.com", # invalid allow
+    "[valid]\nallow one.two.com\ndeny *.testing something.com", # invalid deny
+    ].each do |failer|
+      File.open(config, "w") { |f| f.puts failer }
+      assert_raise(Puppet::Network::Handler::FileServerError, "Did not fail on #{failer.inspect}") {
 
-                server = Puppet::Network::Handler::FileServer.new(
+        server = Puppet::Network::Handler::FileServer.new(
 
-                    :Local => false,
+          :Local => false,
 
-                    :Config => config
-                )
-            }
-        end
+          :Config => config
+        )
+      }
     end
-
-    def test_can_start_without_configuration
-        Puppet[:fileserverconfig] = tempfile
-        assert_nothing_raised("Could not create fileserver when configuration is absent") do
-            server = Puppet::Network::Handler::FileServer.new(
-                :Local => false
-                )
-        end
+  end
+
+  def test_can_start_without_configuration
+    Puppet[:fileserverconfig] = tempfile
+    assert_nothing_raised("Could not create fileserver when configuration is absent") do
+      server = Puppet::Network::Handler::FileServer.new(
+        :Local => false
+        )
     end
+  end
 
-    def test_creates_default_mounts_when_no_configuration_is_available
-        Puppet[:fileserverconfig] = tempfile
-        server = Puppet::Network::Handler::FileServer.new(:Local => false)
+  def test_creates_default_mounts_when_no_configuration_is_available
+    Puppet[:fileserverconfig] = tempfile
+    server = Puppet::Network::Handler::FileServer.new(:Local => false)
 
-        assert(server.mounted?("plugins"), "Did not create default plugins mount when missing configuration file")
-        assert(server.mounted?("modules"), "Did not create default modules mount when missing configuration file")
-    end
+    assert(server.mounted?("plugins"), "Did not create default plugins mount when missing configuration file")
+    assert(server.mounted?("modules"), "Did not create default modules mount when missing configuration file")
+  end
 end
 
 
diff --git a/test/network/handler/master.rb b/test/network/handler/master.rb
index a802b0a0a..81869ac06 100755
--- a/test/network/handler/master.rb
+++ b/test/network/handler/master.rb
@@ -6,89 +6,89 @@ require 'puppettest'
 require 'puppet/network/handler/master'
 
 class TestMaster < Test::Unit::TestCase
-    include PuppetTest::ServerTest
+  include PuppetTest::ServerTest
 
-    def setup
-        super
-        @master = Puppet::Network::Handler.master.new(:Manifest => tempfile)
+  def setup
+    super
+    @master = Puppet::Network::Handler.master.new(:Manifest => tempfile)
 
-        @catalog = stub 'catalog', :extract => ""
-        Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
-    end
+    @catalog = stub 'catalog', :extract => ""
+    Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
+  end
 
-    def teardown
-        super
-        Puppet::Util::Cacher.expire
-    end
+  def teardown
+    super
+    Puppet::Util::Cacher.expire
+  end
 
-    def test_freshness_is_always_now
-        now1 = mock 'now1'
-        Time.stubs(:now).returns(now1)
+  def test_freshness_is_always_now
+    now1 = mock 'now1'
+    Time.stubs(:now).returns(now1)
 
-        now1.expects(:to_i).returns 10
+    now1.expects(:to_i).returns 10
 
-        assert_equal(@master.freshness, 10, "Did not return current time as freshness")
-    end
+    assert_equal(@master.freshness, 10, "Did not return current time as freshness")
+  end
 
-    def test_hostname_is_used_if_client_is_missing
-        @master.expects(:decode_facts).returns("hostname" => "yay")
-        Puppet::Node::Facts.expects(:new).with { |name, facts| name == "yay" }.returns(stub('facts', :save => nil))
+  def test_hostname_is_used_if_client_is_missing
+    @master.expects(:decode_facts).returns("hostname" => "yay")
+    Puppet::Node::Facts.expects(:new).with { |name, facts| name == "yay" }.returns(stub('facts', :save => nil))
 
-        @master.getconfig("facts")
-    end
+    @master.getconfig("facts")
+  end
 
-    def test_facts_are_saved
-        facts = mock('facts')
-        Puppet::Node::Facts.expects(:new).returns(facts)
-        facts.expects(:save)
+  def test_facts_are_saved
+    facts = mock('facts')
+    Puppet::Node::Facts.expects(:new).returns(facts)
+    facts.expects(:save)
 
-        @master.stubs(:decode_facts)
+    @master.stubs(:decode_facts)
 
-        @master.getconfig("facts", "yaml", "foo.com")
-    end
+    @master.getconfig("facts", "yaml", "foo.com")
+  end
 
-    def test_catalog_is_used_for_compiling
-        facts = stub('facts', :save => nil)
-        Puppet::Node::Facts.stubs(:new).returns(facts)
+  def test_catalog_is_used_for_compiling
+    facts = stub('facts', :save => nil)
+    Puppet::Node::Facts.stubs(:new).returns(facts)
 
-        @master.stubs(:decode_facts)
+    @master.stubs(:decode_facts)
 
-        Puppet::Resource::Catalog.expects(:find).with("foo.com").returns(@catalog)
+    Puppet::Resource::Catalog.expects(:find).with("foo.com").returns(@catalog)
 
-        @master.getconfig("facts", "yaml", "foo.com")
-    end
+    @master.getconfig("facts", "yaml", "foo.com")
+  end
 end
 
 class TestMasterFormats < Test::Unit::TestCase
-    def setup
-        @facts = stub('facts', :save => nil)
-        Puppet::Node::Facts.stubs(:new).returns(@facts)
+  def setup
+    @facts = stub('facts', :save => nil)
+    Puppet::Node::Facts.stubs(:new).returns(@facts)
 
-        @master = Puppet::Network::Handler.master.new(:Code => "")
-        @master.stubs(:decode_facts)
+    @master = Puppet::Network::Handler.master.new(:Code => "")
+    @master.stubs(:decode_facts)
 
-        @catalog = stub 'catalog', :extract => ""
-        Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
-    end
+    @catalog = stub 'catalog', :extract => ""
+    Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
+  end
 
-    def test_marshal_can_be_used
-        @catalog.expects(:extract).returns "myextract"
+  def test_marshal_can_be_used
+    @catalog.expects(:extract).returns "myextract"
 
-        Marshal.expects(:dump).with("myextract").returns "eh"
+    Marshal.expects(:dump).with("myextract").returns "eh"
 
-        @master.getconfig("facts", "marshal", "foo.com")
-    end
+    @master.getconfig("facts", "marshal", "foo.com")
+  end
 
-    def test_yaml_can_be_used
-        extract = mock 'extract'
-        @catalog.expects(:extract).returns extract
+  def test_yaml_can_be_used
+    extract = mock 'extract'
+    @catalog.expects(:extract).returns extract
 
-        extract.expects(:to_yaml).returns "myaml"
+    extract.expects(:to_yaml).returns "myaml"
 
-        @master.getconfig("facts", "yaml", "foo.com")
-    end
+    @master.getconfig("facts", "yaml", "foo.com")
+  end
 
-    def test_failure_when_non_yaml_or_marshal_is_used
-        assert_raise(RuntimeError) { @master.getconfig("facts", "blah", "foo.com") }
-    end
+  def test_failure_when_non_yaml_or_marshal_is_used
+    assert_raise(RuntimeError) { @master.getconfig("facts", "blah", "foo.com") }
+  end
 end
diff --git a/test/network/handler/report.rb b/test/network/handler/report.rb
index ed7a96f57..590dcdb13 100755
--- a/test/network/handler/report.rb
+++ b/test/network/handler/report.rb
@@ -7,77 +7,77 @@ require 'puppet/network/handler/report'
 require 'puppettest/reporttesting'
 
 class TestReportServer < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::Reporttesting
-
-    Report = Puppet::Network::Handler.report
-    Puppet::Util.logmethods(self)
-
-    def mkserver
-        server = nil
-        assert_nothing_raised {
-            server = Puppet::Network::Handler.report.new
-        }
-        server
-    end
-
-    def mkclient(server = nil)
-        server ||= mkserver
-        client = nil
-        assert_nothing_raised {
-            client = Puppet::Network::Client.report.new(:Report => server)
-        }
-
-        client
-    end
-
-    def test_process
-        server = Puppet::Network::Handler.report.new
-
-        # We have to run multiple reports to make sure there's no conflict
-        reports = []
-        $run = []
-        2.times do |i|
-            name = "processtest#{i}"
-            reports << name
-
-            Report.newreport(name) do
-                def process
-                    $run << self.report_name
-                end
-            end
+  include PuppetTest
+  include PuppetTest::Reporttesting
+
+  Report = Puppet::Network::Handler.report
+  Puppet::Util.logmethods(self)
+
+  def mkserver
+    server = nil
+    assert_nothing_raised {
+      server = Puppet::Network::Handler.report.new
+    }
+    server
+  end
+
+  def mkclient(server = nil)
+    server ||= mkserver
+    client = nil
+    assert_nothing_raised {
+      client = Puppet::Network::Client.report.new(:Report => server)
+    }
+
+    client
+  end
+
+  def test_process
+    server = Puppet::Network::Handler.report.new
+
+    # We have to run multiple reports to make sure there's no conflict
+    reports = []
+    $run = []
+    2.times do |i|
+      name = "processtest#{i}"
+      reports << name
+
+      Report.newreport(name) do
+        def process
+          $run << self.report_name
         end
-        Puppet[:reports] = reports.collect { |r| r.to_s }.join(",")
-
-        report = fakereport
+      end
+    end
+    Puppet[:reports] = reports.collect { |r| r.to_s }.join(",")
 
-        retval = nil
-        assert_nothing_raised {
-            retval = server.send(:process, YAML.dump(report))
-        }
+    report = fakereport
 
-        reports.each do |name|
-            assert($run.include?(name.intern), "Did not run #{name}")
-        end
+    retval = nil
+    assert_nothing_raised {
+      retval = server.send(:process, YAML.dump(report))
+    }
 
-        # Now make sure our server doesn't die on missing reports
-        Puppet[:reports] = "fakereport"
-        assert_nothing_raised {
-            retval = server.send(:process, YAML.dump(report))
-        }
+    reports.each do |name|
+      assert($run.include?(name.intern), "Did not run #{name}")
     end
 
-    def test_reports
-        Puppet[:reports] = "myreport"
+    # Now make sure our server doesn't die on missing reports
+    Puppet[:reports] = "fakereport"
+    assert_nothing_raised {
+      retval = server.send(:process, YAML.dump(report))
+    }
+  end
 
-        # Create a server
-        server = Puppet::Network::Handler.report.new
+  def test_reports
+    Puppet[:reports] = "myreport"
 
-        {"myreport" => ["myreport"],
-            " fake, another, yay " => ["fake", "another", "yay"]
-        }.each do |str, ary|
-            Puppet[:reports] = str
-            assert_equal(ary, server.send(:reports))
-        end
+    # Create a server
+    server = Puppet::Network::Handler.report.new
+
+    {"myreport" => ["myreport"],
+      " fake, another, yay " => ["fake", "another", "yay"]
+    }.each do |str, ary|
+      Puppet[:reports] = str
+      assert_equal(ary, server.send(:reports))
     end
+  end
 end
diff --git a/test/network/handler/runner.rb b/test/network/handler/runner.rb
index 6bf783b6f..396568b29 100755
--- a/test/network/handler/runner.rb
+++ b/test/network/handler/runner.rb
@@ -6,15 +6,15 @@ require 'puppettest'
 require 'puppet/network/handler/runner'
 
 class TestHandlerRunner < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def test_it_calls_agent_runner
-        runner = mock 'runner'
-        Puppet::Run.expects(:new).with(:tags => "mytags", :ignoreschedules => true, :background => false).returns runner
-        runner.expects(:run)
-        runner.expects(:status).returns "yay"
+  def test_it_calls_agent_runner
+    runner = mock 'runner'
+    Puppet::Run.expects(:new).with(:tags => "mytags", :ignoreschedules => true, :background => false).returns runner
+    runner.expects(:run)
+    runner.expects(:status).returns "yay"
 
 
-        assert_equal("yay", Puppet::Network::Handler.runner.new.run("mytags", true, true))
-    end
+    assert_equal("yay", Puppet::Network::Handler.runner.new.run("mytags", true, true))
+  end
 end