puppet 2.7.3 → 2.7.4

data/spec/unit/parser/compiler_spec.rb

@@ -43,6 +43,8 @@ class CompilerTestResource
 end
 
 describe Puppet::Parser::Compiler do
+  include PuppetSpec::Files
+
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
@@ -413,7 +415,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should fail to add resources that conflict with existing resources" do
-      path = Puppet.features.posix? ? "/foo" : "C:/foo"
+      path = make_absolute("/foo")
       file1 = Puppet::Type.type(:file).new :path => path
       file2 = Puppet::Type.type(:file).new :path => path
 

data/spec/unit/parser/files_spec.rb

@@ -4,9 +4,10 @@ require 'spec_helper'
 require 'puppet/parser/files'
 
 describe Puppet::Parser::Files do
+  include PuppetSpec::Files
 
   before do
-    @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
+    @basepath = make_absolute("/somepath")
   end
 
   it "should have a method for finding a template" do
@@ -77,8 +78,9 @@ describe Puppet::Parser::Files do
     it "should accept relative templatedirs" do
       FileTest.stubs(:exist?).returns true
       Puppet[:templatedir] = "my/templates"
-      File.expects(:directory?).with(File.join(Dir.getwd,"my/templates")).returns(true)
-      Puppet::Parser::Files.find_template("mytemplate").should == File.join(Dir.getwd,"my/templates/mytemplate")
+      # We expand_path to normalize backslashes and slashes on Windows
+      File.expects(:directory?).with(File.expand_path(File.join(Dir.getwd,"my/templates"))).returns(true)
+      Puppet::Parser::Files.find_template("mytemplate").should == File.expand_path(File.join(Dir.getwd,"my/templates/mytemplate"))
     end
 
     it "should use the environment templatedir if no module is found and an environment is specified" do
@@ -158,7 +160,8 @@ describe Puppet::Parser::Files do
     end
 
     it "should look for files relative to the current directory" do
-      cwd = Dir.getwd
+      # We expand_path to normalize backslashes and slashes on Windows
+      cwd = File.expand_path(Dir.getwd)
       Dir.expects(:glob).with("#{cwd}/foobar/init.pp").returns(["#{cwd}/foobar/init.pp"])
       Puppet::Parser::Files.find_manifests("foobar/init.pp")[1].should == ["#{cwd}/foobar/init.pp"]
     end

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

@@ -3,6 +3,8 @@ require 'spec_helper'
 require 'tempfile'
 
 describe "the extlookup function" do
+  include PuppetSpec::Files
+
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
@@ -64,9 +66,10 @@ describe "the extlookup function" do
 
   describe "should look in $extlookup_datadir for data files listed by $extlookup_precedence" do
     before do
-      @scope.stubs(:lookupvar).with('::extlookup_datadir').returns("/tmp")
-      File.open("/tmp/one.csv","w"){|one| one.puts "key,value1" }
-      File.open("/tmp/two.csv","w") do |two|
+      dir = tmpdir('extlookup_datadir')
+      @scope.stubs(:lookupvar).with('::extlookup_datadir').returns(dir)
+      File.open(File.join(dir, "one.csv"),"w"){|one| one.puts "key,value1" }
+      File.open(File.join(dir, "two.csv"),"w") do |two|
         two.puts "key,value2"
         two.puts "key2,value_two"
       end

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

@@ -30,7 +30,8 @@ describe "the sprintf function" do
 
   it "should format large floats" do
     result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
-    result.should(eql("+2.72e+16"))
+    str = Puppet.features.microsoft_windows? ? "+2.72e+016" : "+2.72e+16"
+    result.should(eql(str))
   end
 
   it "should perform more complex formatting" do

data/spec/unit/parser/type_loader_spec.rb

@@ -56,8 +56,8 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should use the directory of the current file if one is set" do
-      Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == "/current" }.returns ["modname", %w{one}]
-      @loader.import("myfile", "/current/file")
+      Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == make_absolute("/current") }.returns ["modname", %w{one}]
+      @loader.import("myfile", make_absolute("/current/file"))
     end
 
     it "should pass the environment when looking for files" do
@@ -71,15 +71,15 @@ describe Puppet::Parser::TypeLoader do
     end
 
     it "should parse each found file" do
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      @loader.expects(:parse_file).with("/one").returns(Puppet::Parser::AST::Hostclass.new(''))
+      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
+      @loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
     end
 
     it "should make each file qualified before attempting to parse it" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-      @loader.expects(:parse_file).with("/current/one").returns(Puppet::Parser::AST::Hostclass.new(''))
-      @loader.import("myfile", "/current/file")
+      @loader.expects(:parse_file).with(make_absolute("/current/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
+      @loader.import("myfile", make_absolute("/current/file"))
     end
 
     it "should not attempt to import files that have already been imported" do
@@ -102,7 +102,7 @@ describe Puppet::Parser::TypeLoader do
       @modulebase2 = File.join(@base, "second")
       FileUtils.mkdir_p(@modulebase2)
 
-      Puppet[:modulepath] = "#{@modulebase1}:#{@modulebase2}"
+      Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
     end
 
     def mk_module(basedir, name)

data/spec/unit/property_spec.rb

@@ -109,7 +109,7 @@ describe Puppet::Property do
     end
   end
 
-  describe "when creating an event" do
+  describe "when creating an event", :fails_on_windows => true do
     before do
       @event = Puppet::Transaction::Event.new
 

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -442,6 +442,20 @@ describe provider_class do
         @provider.expects(:diff).with("#{file}", "#{file}.augnew").returns("")
         @provider.should be_need_to_run
       end
+
+      it "should fail with an error if saving fails" do
+        file = "/etc/hosts"
+
+        @resource[:context] = "/files"
+        @resource[:changes] = ["set #{file}/foo bar"]
+
+        @augeas_stub.stubs(:save).returns(false)
+        @augeas_stub.stubs(:match).with("/augeas/events/saved").returns([])
+        @augeas_stub.expects(:close)
+
+        @provider.expects(:diff).never()
+        lambda { @provider.need_to_run? }.should raise_error
+      end
     end
   end
 

data/spec/unit/provider/exec/posix_spec.rb

@@ -1,120 +1,116 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:exec).provider(:posix)
+describe Puppet::Type.type(:exec).provider(:posix) do
+  include PuppetSpec::Files
+
+  def make_exe
+    command = tmpfile('my_command')
+    FileUtils.touch(command)
+    File.chmod(0755, command)
+    command
+  end
+
+  let(:resource) { Puppet::Type.type(:exec).new(:title => File.expand_path('/foo'), :provider => :posix) }
+  let(:provider) { described_class.new(resource) }
+
+  describe "#validatecmd" do
+    it "should fail if no path is specified and the command is not fully qualified" do
+      expect { provider.validatecmd("foo") }.to raise_error(
+        Puppet::Error,
+        "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
+      )
+    end
 
-describe provider_class do
-  before :each do
-    @resource = Puppet::Resource.new(:exec, 'foo')
-    @provider = provider_class.new(@resource)
+    it "should pass if a path is given" do
+      provider.resource[:path] = ['/bogus/bin']
+      provider.validatecmd("../foo")
+    end
+
+    it "should pass if command is fully qualifed" do
+      provider.resource[:path] = ['/bogus/bin']
+      provider.validatecmd(File.expand_path("/bin/blah/foo"))
+    end
   end
 
-  ["posix", "microsoft_windows"].each do |feature|
-    describe "when in #{feature} environment" do
-      before :each do
-        if feature == "microsoft_windows"
-          Puppet.features.stubs(:microsoft_windows?).returns(true)
-          Puppet.features.stubs(:posix?).returns(false)
-        else
-          Puppet.features.stubs(:posix?).returns(true)
-          Puppet.features.stubs(:microsoft_windows?).returns(false)
-        end
+  describe "#run" do
+    describe "when the command is an absolute path" do
+      let(:command) { tmpfile('foo') }
+
+      it "should fail if the command doesn't exist" do
+        expect { provider.run(command) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
+      end
+
+      it "should fail if the command isn't a file" do
+        FileUtils.mkdir(command)
+        FileUtils.chmod(0755, command)
+
+        expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is a directory, not a file")
+      end
+
+      it "should fail if the command isn't executable" do
+        FileUtils.touch(command)
+        File.stubs(:executable?).with(command).returns(false)
+
+        expect { provider.run(command) }.to raise_error(ArgumentError, "'#{command}' is not executable")
+      end
+    end
+
+    describe "when the command is a relative path" do
+      it "should execute the command if it finds it in the path and is executable" do
+        command = make_exe
+        provider.resource[:path] = [File.dirname(command)]
+        filename = File.basename(command)
+
+        Puppet::Util.expects(:execute).with { |cmdline, arguments| (cmdline == filename) && (arguments.is_a? Hash) }
+
+        provider.run(filename)
       end
 
-      describe "#validatecmd" do
-        it "should fail if no path is specified and the command is not fully qualified" do
-          lambda { @provider.validatecmd("foo") }.should raise_error(
-            Puppet::Error,
-            "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
-          )
-        end
-
-        it "should pass if a path is given" do
-          @provider.resource[:path] = ['/bogus/bin']
-          @provider.validatecmd("../foo")
-        end
-
-        it "should pass if command is fully qualifed" do
-          @provider.resource[:path] = ['/bogus/bin']
-          @provider.validatecmd("/bin/blah/foo")
-        end
+      it "should fail if the command isn't in the path" do
+        resource[:path] = ["/fake/path"]
+
+        expect { provider.run('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
       end
 
-      describe "#run" do
-        it "should fail if no path is specified and command does not exist" do
-          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
-        end
-
-        it "should fail if the command isn't in the path" do
-          @provider.resource[:path] = ['/bogus/bin']
-          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
-        end
-
-        it "should fail if the command isn't executable" do
-          @provider.resource[:path] = ['/bogus/bin']
-          File.stubs(:exists?).with("foo").returns(true)
-
-          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "'foo' is not executable")
-        end
-
-        it "should not be able to execute shell builtins" do
-          @provider.resource[:path] = ['/bin']
-          lambda { @provider.run("cd ..") }.should raise_error(ArgumentError, "Could not find command 'cd'")
-        end
-
-        it "should execute the command if the command given includes arguments or subcommands" do
-          @provider.resource[:path] = ['/bogus/bin']
-          File.stubs(:exists?).returns(false)
-          File.stubs(:exists?).with("foo").returns(true)
-          File.stubs(:executable?).with("foo").returns(true)
-
-          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo bar --sillyarg=true --blah']) && (arguments.is_a? Hash) }
-          @provider.run("foo bar --sillyarg=true --blah")
-        end
-
-        it "should fail if quoted command doesn't exist" do
-          @provider.resource[:path] = ['/bogus/bin']
-          File.stubs(:exists?).returns(false)
-          File.stubs(:exists?).with("foo").returns(true)
-          File.stubs(:executable?).with("foo").returns(true)
-
-          lambda { @provider.run('"foo bar --sillyarg=true --blah"') }.should raise_error(ArgumentError, "Could not find command 'foo bar --sillyarg=true --blah'")
-        end
-
-        it "should execute the command if it finds it in the path and is executable" do
-          @provider.resource[:path] = ['/bogus/bin']
-          File.stubs(:exists?).with("foo").returns(true)
-          File.stubs(:executable?).with("foo").returns(true)
-          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
-
-          @provider.run("foo")
-        end
-
-        if feature == "microsoft_windows"
-          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
-            it "should check file extension #{extension} when it can't find the executable" do
-              @provider.resource[:path] = ['/bogus/bin']
-              File.stubs(:exists?).returns(false)
-              File.stubs(:exists?).with("/bogus/bin/foo#{extension}").returns(true)
-              File.stubs(:executable?).with("foo").returns(true)
-              Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
-
-              @provider.run("foo")
-            end
-          end
-        end
-
-        it "should warn if you're overriding something in environment" do
-          @provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
-          File.stubs(:exists?).returns(false)
-          File.stubs(:exists?).with("foo").returns(true)
-          File.stubs(:executable?).with("foo").returns(true)
-
-          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
-          @provider.run("foo")
-          @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
-        end
+      it "should fail if the command is in the path but not executable" do
+        command = tmpfile('foo')
+        FileUtils.touch(command)
+        FileTest.stubs(:executable?).with(command).returns(false)
+        resource[:path] = [File.dirname(command)]
+        filename = File.basename(command)
+
+        expect { provider.run(filename) }.to raise_error(ArgumentError, "Could not find command '#{filename}'")
       end
     end
+
+    it "should not be able to execute shell builtins" do
+      provider.resource[:path] = ['/bin']
+      expect { provider.run("cd ..") }.to raise_error(ArgumentError, "Could not find command 'cd'")
+    end
+
+    it "should execute the command if the command given includes arguments or subcommands" do
+      provider.resource[:path] = ['/bogus/bin']
+      command = make_exe
+
+      Puppet::Util.expects(:execute).with { |cmdline, arguments| (cmdline == "#{command} bar --sillyarg=true --blah") && (arguments.is_a? Hash) }
+      provider.run("#{command} bar --sillyarg=true --blah")
+    end
+
+    it "should fail if quoted command doesn't exist" do
+      provider.resource[:path] = ['/bogus/bin']
+      command = "#{File.expand_path('/foo')} bar --sillyarg=true --blah"
+
+      expect { provider.run(%Q["#{command}"]) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
+    end
+
+    it "should warn if you're overriding something in environment" do
+      provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
+      command = make_exe
+
+      Puppet::Util.expects(:execute).with { |cmdline, arguments| (cmdline == command) && (arguments.is_a? Hash) }
+      provider.run(command)
+      @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
+    end
   end
 end

data/spec/unit/provider/exec/shell_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 provider_class = Puppet::Type.type(:exec).provider(:shell)
 
-describe provider_class do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
   before :each do
     @resource = Puppet::Resource.new(:exec, 'foo')
     @provider = provider_class.new(@resource)

data/spec/unit/provider/exec/windows_spec.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:exec).provider(:windows) do
+  include PuppetSpec::Files
+
+  let(:resource) { Puppet::Type.type(:exec).new(:title => 'C:\foo', :provider => :windows) }
+  let(:provider) { described_class.new(resource) }
+
+  before :each do
+    Puppet.features.stubs(:microsoft_windows?).returns(true)
+    Puppet.features.stubs(:posix?).returns(false)
+  end
+
+  after :all do
+    # This provider may not be suitable on some machines, so we want to reset
+    # the default so it isn't used by mistake in future specs.
+    Puppet::Type.type(:exec).defaultprovider = nil
+  end
+
+  describe "#extractexe" do
+    describe "when the command has no arguments" do
+      it "should return the command if it's quoted" do
+        provider.extractexe('"foo"').should == 'foo'
+      end
+
+      it "should return the command if it's quoted and contains spaces" do
+        provider.extractexe('"foo bar"').should == 'foo bar'
+      end
+
+      it "should return the command if it's not quoted" do
+        provider.extractexe('foo').should == 'foo'
+      end
+    end
+
+    describe "when the command has arguments" do
+      it "should return the command if it's quoted" do
+        provider.extractexe('"foo" bar baz').should == 'foo'
+      end
+
+      it "should return the command if it's quoted and contains spaces" do
+        provider.extractexe('"foo bar" baz "quux quiz"').should == 'foo bar'
+      end
+
+      it "should return the command if it's not quoted" do
+        provider.extractexe('foo bar baz').should == 'foo'
+      end
+    end
+  end
+
+  describe "#checkexe" do
+    describe "when the command is absolute", :if => Puppet.features.microsoft_windows? do
+      it "should return if the command exists and is a file" do
+        command = tmpfile('command')
+        FileUtils.touch(command)
+
+        provider.checkexe(command).should == nil
+      end
+      it "should fail if the command doesn't exist" do
+        command = tmpfile('command')
+
+        expect { provider.checkexe(command) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
+      end
+      it "should fail if the command isn't a file" do
+        command = tmpfile('command')
+        FileUtils.mkdir(command)
+
+        expect { provider.checkexe(command) }.to raise_error(ArgumentError, "'#{command}' is a directory, not a file")
+      end
+    end
+
+    describe "when the command is relative" do
+      describe "and a path is specified" do
+        before :each do
+          provider.stubs(:which)
+        end
+
+        it "should search for executables with no extension" do
+          provider.expects(:which).with('foo').returns('foo')
+
+          provider.checkexe('foo')
+        end
+
+        %w[bat com ps1 exe].each do |ext|
+          it "should search for executables with the extension '#{ext}'" do
+            provider.expects(:which).with("foo.#{ext}").returns("foo.#{ext}")
+
+            provider.checkexe('foo')
+          end
+        end
+
+        it "should fail if the command isn't in the path" do
+          expect { provider.checkexe('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+      end
+
+      it "should fail if no path is specified" do
+        expect { provider.checkexe('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
+      end
+    end
+  end
+
+  describe "#validatecmd" do
+    it "should fail if the command isn't absolute and there is no path" do
+      expect { provider.validatecmd('foo') }.to raise_error(Puppet::Error, /'foo' is not qualified and no path was specified/)
+    end
+
+    it "should not fail if the command is absolute and there is no path" do
+      provider.validatecmd('C:\foo').should == nil
+    end
+
+    it "should not fail if the command is not absolute and there is a path" do
+      resource[:path] = 'C:\path;C:\another_path'
+
+      provider.validatecmd('foo').should == nil
+    end
+  end
+end

data/spec/unit/provider/group/ldap_spec.rb

@@ -1,8 +1,4 @@
 #!/usr/bin/env rspec
-#
-#  Created by Luke Kanies on 2008-3-10.
-#  Copyright (c) 2006. All rights reserved.
-
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:group).provider(:ldap)

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:group).provider(:windows_adsi) do
+  let(:resource) do
+    Puppet::Type.type(:group).new(
+      :title => 'testers',
+      :provider => :windows_adsi
+    )
+  end
+
+  let(:provider) { resource.provider }
+
+  let(:connection) { stub 'connection' }
+
+  before :each do
+    Puppet::Util::ADSI.stubs(:computer_name).returns('testcomputername')
+    Puppet::Util::ADSI.stubs(:connect).returns connection
+  end
+
+  describe ".instances" do
+    it "should enumerate all groups" do
+      names = ['group1', 'group2', 'group3']
+      stub_groups = names.map{|n| stub(:name => n)}
+
+      connection.stubs(:execquery).with("select * from win32_group").returns stub_groups
+
+      described_class.instances.map(&:name).should =~ names
+    end
+  end
+
+  describe "when managing members" do
+    it "should be able to provide a list of members" do
+      provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
+
+      provider.members.should =~ ['user1', 'user2', 'user3']
+    end
+
+    it "should be able to set group members" do
+      provider.group.stubs(:members).returns ['user1', 'user2']
+
+      provider.group.expects(:remove_members).with('user1')
+      provider.group.expects(:add_members).with('user3')
+
+      provider.members = ['user2', 'user3']
+    end
+  end
+
+  it "should be able to create a group" do
+    resource[:members] = ['user1', 'user2']
+
+    group = stub 'group'
+    Puppet::Util::ADSI::Group.expects(:create).with('testers').returns group
+
+    group.expects(:set_members).with(['user1', 'user2'])
+
+    provider.create
+  end
+
+  it "should be able to test whether a group exists" do
+    Puppet::Util::ADSI.stubs(:connect).returns stub('connection')
+    provider.should be_exists
+
+    Puppet::Util::ADSI.stubs(:connect).returns nil
+    provider.should_not be_exists
+  end
+
+  it "should be able to delete a group" do
+    connection.expects(:Delete).with('group', 'testers')
+
+    provider.delete
+  end
+
+  it "should warn when trying to manage the gid property" do
+    provider.expects(:warning).with { |msg| msg =~ /No support for managing property gid/ }
+    provider.send(:gid=, 500)
+  end
+end

data/spec/unit/provider/ldap_spec.rb

@@ -1,8 +1,4 @@
 #!/usr/bin/env rspec
-#
-#  Created by Luke Kanies on 2008-3-21.
-#  Copyright (c) 2006. All rights reserved.
-
 require 'spec_helper'
 
 require 'puppet/provider/ldap'

data/spec/unit/provider/macauthorization_spec.rb

@@ -106,6 +106,11 @@ describe provider_class do
     end
 
     it "should call the internal method set_right" do
+      @provider.expects(:execute).with { |cmds, args|
+        cmds.include?("read") and
+        cmds.include?(@authname) and
+        args[:combine] == false
+      }.once
       @provider.expects(:set_right)
       @provider.flush
     end

data/spec/unit/provider/mount/parsed_spec.rb

@@ -1,14 +1,10 @@
 #!/usr/bin/env rspec
-#
-#  Created by Luke Kanies on 2007-9-12.
-#  Copyright (c) 2006. All rights reserved.
-
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
-describe provider_class do
+describe provider_class, :fails_on_windows => true do
 
   before :each do
     @mount_class = Puppet::Type.type(:mount)