puppet 0.25.5 → 2.6.0

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

@@ -1,194 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-9-12.
-#  Copyright (c) 2006. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppettest/support/utils'
-require 'puppettest/fileparsing'
-
-module ParsedMountTesting
-    include PuppetTest::Support::Utils
-    include PuppetTest::FileParsing
-
-    def fake_fstab
-        os = Facter['operatingsystem']
-        if os == "Solaris"
-            name = "solaris.fstab"
-        elsif os == "FreeBSD"
-            name = "freebsd.fstab"
-        else
-            # Catchall for other fstabs
-            name = "linux.fstab"
-        end
-        oldpath = @provider_class.default_target
-        return fakefile(File::join("data/types/mount", name))
-    end
-
-    def mkmountargs
-        mount = nil
-
-        if defined? @pcount
-            @pcount += 1
-        else
-            @pcount = 1
-        end
-        args = {
-            :name => "/fspuppet%s" % @pcount,
-            :device => "/dev/dsk%s" % @pcount,
-        }
-
-        @provider_class.fields(:parsed).each do |field|
-            unless args.include? field
-                args[field] = "fake%s%s" % [field, @pcount]
-            end
-        end
-
-        return args
-    end
-
-    def mkmount
-        hash = mkmountargs()
-        #hash[:provider] = @provider_class.name
-
-        fakeresource = stub :type => :mount, :name => hash[:name]
-        fakeresource.stubs(:[]).with(:name).returns(hash[:name])
-        fakeresource.stubs(:should).with(:target).returns(nil)
-
-        mount = @provider_class.new(fakeresource)
-        hash[:record_type] = :parsed
-        hash[:ensure] = :present
-        mount.property_hash = hash
-
-        return mount
-    end
-
-    # Here we just create a fake host type that answers to all of the methods
-    # but does not modify our actual system.
-    def mkfaketype
-        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-    end
-end
-
-provider_class = Puppet::Type.type(:mount).provider(:parsed)
-
-describe provider_class do
-    before :each do
-        @mount_class = Puppet::Type.type(:mount)
-        @provider_class = @mount_class.provider(:parsed)
-    end
-
-
-    describe provider_class do
-        include ParsedMountTesting
-
-        it "should be able to parse all of the example mount tabs" do
-            tab = fake_fstab
-            @provider = @provider_class
-
-            # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
-            # I suppose this is more of an integration test?  I dunno.
-            fakedataparse(tab) do
-                # Now just make we've got some mounts we know will be there
-                hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
-                (hashes.length > 0).should be_true
-                root = hashes.find { |i| i[:name] == "/" }
-
-                proc { @provider_class.to_file(hashes) }.should_not raise_error
-            end
-        end
-
-        # LAK:FIXME I can't mock Facter because this test happens at parse-time.
-        it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
-            should = case Facter.value(:operatingsystem)
-                when "Solaris"; "/etc/vfstab"
-                else
-                    "/etc/fstab"
-                end
-            Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
-        end
-
-        it "should not crash on incomplete lines in fstab" do
-            parse = @provider_class.parse <<-FSTAB
-/dev/incomplete
-/dev/device       name
-            FSTAB
-
-            lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
-        end
-    end
-
-    describe provider_class, " when mounting an absent filesystem" do
-        include ParsedMountTesting
-
-        # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
-        it "should flush the fstab to disk" do
-            mount = mkmount
-
-            # Mark the mount as absent
-            mount.property_hash[:ensure] = :absent
-
-            mount.stubs(:mountcmd) # just so we don't actually try to mount anything
-
-            mount.expects(:flush)
-            mount.mount
-        end
-    end
-
-    describe provider_class, " when modifying the filesystem tab" do
-        include ParsedMountTesting
-        before do
-            Puppet.settings.stubs(:use)
-            # Never write to disk, only to RAM.
-            #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-            @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
-
-            @mount = mkmount
-            @target = @provider_class.default_target
-        end
-
-        it "should write the mount to disk when :flush is called" do
-            old_text = @provider_class.target_object(@provider_class.default_target).read
-            
-            @mount.flush
-
-            text = @provider_class.target_object(@provider_class.default_target).read
-            text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
-        end
-    end
-
-    describe provider_class, " when parsing information about the root filesystem" do
-        confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
-        include ParsedMountTesting
-
-        before do
-            @mount = @mount_class.new :name => "/"
-            @provider = @mount.provider
-        end
-
-        it "should have a filesystem tab" do
-            FileTest.should be_exist(@provider_class.default_target)
-        end
-
-        it "should find the root filesystem" do
-            @provider_class.prefetch("/" => @mount)
-            @mount.provider.property_hash[:ensure].should == :present
-        end
-
-        it "should determine that the root fs is mounted" do
-            @provider_class.prefetch("/" => @mount)
-            @mount.provider.should be_mounted
-        end
-    end
-
-    describe provider_class, " when mounting and unmounting" do
-        include ParsedMountTesting
-
-        it "should call the 'mount' command to mount the filesystem"
-
-        it "should call the 'unmount' command to unmount the filesystem"
-
-        it "should specify the filesystem when remounting a filesystem"
-    end
-end

data/spec/unit/provider/naginator.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/provider/naginator'
-
-describe Puppet::Provider::Naginator do
-    before do
-        @resource_type = stub 'resource_type', :name => :nagios_test
-        @class = Class.new(Puppet::Provider::Naginator)
-
-        @class.stubs(:resource_type).returns @resource_type
-    end
-
-    it "should be able to look up the associated Nagios type" do
-        nagios_type = mock "nagios_type"
-        nagios_type.stubs :attr_accessor
-        Nagios::Base.expects(:type).with(:test).returns nagios_type
-
-        @class.nagios_type.should equal(nagios_type)
-    end
-
-    it "should use the Nagios type to determine whether an attribute is valid" do
-        nagios_type = mock "nagios_type"
-        nagios_type.stubs :attr_accessor
-        Nagios::Base.expects(:type).with(:test).returns nagios_type
-
-        nagios_type.expects(:parameters).returns [:foo, :bar]
-
-        @class.valid_attr?(:test, :foo).should be_true
-    end
-
-    it "should use Naginator to parse configuration snippets" do
-        parser = mock 'parser'
-        parser.expects(:parse).with("my text").returns "my instances"
-        Nagios::Parser.expects(:new).returns(parser)
-
-        @class.parse("my text").should == "my instances"
-    end
-
-    it "should join Nagios::Base records with '\\n' when asked to convert them to text" do
-        @class.expects(:header).returns "myheader\n"
-
-        @class.to_file([:one, :two]).should == "myheader\none\ntwo"
-    end
-
-    it "should be able to prefetch instance from configuration files" do
-        @class.should respond_to(:prefetch)
-    end
-
-    it "should be able to generate a list of instances" do
-        @class.should respond_to(:instances)
-    end
-
-    it "should never skip records" do
-        @class.should_not be_skip_record("foo")
-    end
-end

data/spec/unit/provider/package/apt.rb

@@ -1,138 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-provider = Puppet::Type.type(:package).provider(:apt)
-
-describe provider do
-    before do
-        @resource = stub 'resource', :[] => "asdf"
-        @provider = provider.new(@resource)
-
-        @fakeresult = "install ok installed asdf 1.0\n"
-    end
-
-    it "should be versionable" do
-        provider.should be_versionable
-    end
-
-    it "should use :install to update" do
-        @provider.expects(:install)
-        @provider.update
-    end
-
-    it "should use 'apt-get remove' to uninstall" do
-        @provider.expects(:aptget).with("-y", "-q", :remove, "asdf")
-
-        @provider.uninstall
-    end
-
-    it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-        @provider.expects(:aptget).with("-y", "-q", :remove, "--purge", "asdf")
-        @provider.expects(:dpkg).with("--purge", "asdf")
-
-        @provider.purge
-    end
-
-    it "should use 'apt-cache policy' to determine the latest version of a package" do
-        @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:
-Installed: 1:1.0
-Candidate: 1:1.1
-Version table:
- 1:1.0
-    650 http://ftp.osuosl.org testing/main Packages
-*** 1:1.1
-    100 /var/lib/dpkg/status"
-
-        @provider.latest.should == "1:1.1"
-    end
-
-    it "should print and error and return nil if no policy is found" do
-        @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:"
-
-        @provider.expects(:err)
-        @provider.latest.should be_nil
-    end
-
-    it "should be able to preseed" do
-        @provider.should respond_to(:run_preseed)
-    end
-
-    it "should preseed with the provided responsefile when preseeding is called for" do
-        @resource.expects(:[]).with(:responsefile).returns "/my/file"
-        FileTest.expects(:exist?).with("/my/file").returns true
-
-        @provider.expects(:info)
-        @provider.expects(:preseed).with("/my/file")
-
-        @provider.run_preseed
-    end
-
-    it "should not preseed if no responsefile is provided" do
-        @resource.expects(:[]).with(:responsefile).returns nil
-
-        @provider.expects(:info)
-        @provider.expects(:preseed).never
-
-        @provider.run_preseed
-    end
-
-    it "should fail if a cdrom is listed in the sources list and :allowcdrom is not specified"
-
-    describe "when installing" do
-        it "should preseed if a responsefile is provided" do
-            @resource.expects(:[]).with(:responsefile).returns "/my/file"
-            @provider.expects(:run_preseed)
-
-            @provider.stubs(:aptget)
-            @provider.install
-        end
-
-        it "should check for a cdrom" do
-            @provider.expects(:checkforcdrom)
-
-            @provider.stubs(:aptget)
-            @provider.install
-        end
-
-        it "should use 'apt-get install' with the package name if no version is asked for" do
-            @resource.expects(:[]).with(:ensure).returns :installed
-            @provider.expects(:aptget).with { |*command| command[-1] == "asdf" and command[-2] == :install }
-
-            @provider.install
-        end
-
-        it "should specify the package version if one is asked for" do
-            @resource.expects(:[]).with(:ensure).returns "1.0"
-            @provider.expects(:aptget).with { |*command| command[-1] == "asdf=1.0" }
-
-            @provider.install
-        end
-
-        it "should do a quiet install" do
-            @provider.expects(:aptget).with { |*command| command.include?("-q") }
-
-            @provider.install
-        end
-
-        it "should default to 'yes' for all questions" do
-            @provider.expects(:aptget).with { |*command| command.include?("-y") }
-
-            @provider.install
-        end
-
-        it "should keep config files if asked" do
-            @resource.expects(:[]).with(:configfiles).returns :keep
-            @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
-
-            @provider.install
-        end
-
-        it "should replace config files if asked" do
-            @resource.expects(:[]).with(:configfiles).returns :replace
-            @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
-
-            @provider.install
-        end
-    end
-end

data/spec/unit/provider/package/dpkg.rb

@@ -1,170 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-provider = Puppet::Type.type(:package).provider(:dpkg)
-
-describe provider do
-    before do
-        @resource = stub 'resource', :[] => "asdf"
-        @provider = provider.new(@resource)
-
-        @fakeresult = "install ok installed asdf 1.0\n"
-    end
-
-    it "should have documentation" do
-        provider.doc.should be_instance_of(String)
-    end
-
-    describe "when listing all instances" do
-        before do
-            provider.stubs(:command).with(:dpkgquery).returns "myquery"
-        end
-
-        it "should use dpkg-query" do
-            provider.expects(:command).with(:dpkgquery).returns "myquery"
-            provider.expects(:execpipe).with("myquery -W --showformat '${Status} ${Package} ${Version}\\n'").returns @fakeresult
-
-            provider.instances
-        end
-
-        it "should create and return an instance with each parsed line from dpkg-query" do
-            pipe = mock 'pipe'
-            pipe.expects(:each).yields @fakeresult
-            provider.expects(:execpipe).yields pipe
-
-            asdf = mock 'pkg1'
-            provider.expects(:new).with(:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg).returns asdf
-
-            provider.instances.should == [asdf]
-        end
-
-        it "should warn on and ignore any lines it does not understand" do
-            pipe = mock 'pipe'
-            pipe.expects(:each).yields "foobar"
-            provider.expects(:execpipe).yields pipe
-
-            Puppet.expects(:warning)
-            provider.expects(:new).never
-
-            provider.instances.should == []
-        end
-    end
-
-    describe "when querying the current state" do
-        it "should use dpkg-query" do
-            @provider.expects(:dpkgquery).with("-W", "--showformat",'${Status} ${Package} ${Version}\\n', "asdf").returns @fakeresult
-
-            @provider.query
-        end
-
-        it "should consider the package purged if dpkg-query fails" do
-            @provider.expects(:dpkgquery).raises Puppet::ExecutionFailure.new("eh")
-
-            @provider.query[:ensure].should == :purged
-        end
-
-        it "should return a hash of the found status with the desired state, error state, status, name, and 'ensure'" do
-            @provider.expects(:dpkgquery).returns @fakeresult
-
-            @provider.query.should == {:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg}
-        end
-
-        it "should consider the package absent if the dpkg-query result cannot be interpreted" do
-            @provider.expects(:dpkgquery).returns "somebaddata"
-
-            @provider.query[:ensure].should == :absent
-        end
-
-        it "should fail if an error is discovered" do
-            @provider.expects(:dpkgquery).returns @fakeresult.sub("ok", "error")
-
-            lambda { @provider.query }.should raise_error(Puppet::Error)
-        end
-
-        it "should consider the package purged if it is marked 'not-installed'" do
-            @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "not-installed")
-
-            @provider.query[:ensure].should == :purged
-        end
-
-        it "should consider the package absent if its status is neither 'installed' nor 'not-installed'" do
-            @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "foo")
-
-            @provider.query[:ensure].should == :absent
-        end
-    end
-
-    it "should be able to install" do
-        @provider.should respond_to(:install)
-    end
-
-    describe "when installing" do
-        before do
-            @resource.stubs(:[]).with(:source).returns "mypkg"
-        end
-
-        it "should fail to install if no source is specified in the resource" do
-            @resource.expects(:[]).with(:source).returns nil
-
-            lambda { @provider.install }.should raise_error(ArgumentError)
-        end
-
-        it "should use 'dpkg -i' to install the package" do
-            @resource.expects(:[]).with(:source).returns "mypackagefile"
-            @provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
-
-            @provider.install
-        end
-
-        it "should keep old config files if told to do so" do
-            @resource.expects(:[]).with(:configfiles).returns :keep
-            @provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
-
-            @provider.install
-        end
-
-        it "should replace old config files if told to do so" do
-            @resource.expects(:[]).with(:configfiles).returns :replace
-            @provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
-
-            @provider.install
-        end
-    end
-
-    it "should use :install to update" do
-        @provider.expects(:install)
-        @provider.update
-    end
-
-    describe "when determining latest available version" do
-        it "should return the version found by dpkg-deb" do
-            @resource.expects(:[]).with(:source).returns "myfile"
-            @provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "asdf\t1.0"
-            @provider.latest.should == "1.0"
-        end
-
-        it "should warn if the package file contains a different package" do
-            @provider.expects(:dpkg_deb).returns("foo\tversion")
-            @provider.expects(:warning)
-            @provider.latest
-        end
-
-        it "should cope with names containing ++" do
-            @resource = stub 'resource', :[] => "asdf++"
-            @provider = provider.new(@resource)
-            @provider.expects(:dpkg_deb).returns "asdf++\t1.0"
-            @provider.latest.should == "1.0"
-        end
-    end
-
-    it "should use 'dpkg -r' to uninstall" do
-        @provider.expects(:dpkg).with("-r", "asdf")
-        @provider.uninstall
-    end
-
-    it "should use 'dpkg --purge' to purge" do
-        @provider.expects(:dpkg).with("--purge", "asdf")
-        @provider.purge
-    end
-end