puppet 0.25.5 → 2.6.0

data/spec/unit/type/user.rb

@@ -1,285 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-user = Puppet::Type.type(:user)
-
-describe user do
-    before do
-        unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
-            ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin"
-        end
-        @provider = stub 'provider'
-        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
-    end
-
-    it "should have a default provider inheriting from Puppet::Provider" do
-        user.defaultprovider.ancestors.should be_include(Puppet::Provider)
-    end
-
-    it "should be able to create a instance" do
-        user.new(:name => "foo").should_not be_nil
-    end
-
-    it "should have an allows_duplicates feature" do
-        user.provider_feature(:allows_duplicates).should_not be_nil
-    end
-
-    it "should have an manages_homedir feature" do
-        user.provider_feature(:manages_homedir).should_not be_nil
-    end
-
-    it "should have an manages_passwords feature" do
-        user.provider_feature(:manages_passwords).should_not be_nil
-    end
-
-    it "should have a manages_solaris_rbac feature" do
-        user.provider_feature(:manages_solaris_rbac).should_not be_nil
-    end
-
-    describe "instances" do
-        it "should have a valid provider" do
-            user.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
-        end
-
-        it "should delegate existence questions to its provider" do
-            instance = user.new(:name => "foo")
-            instance.provider.expects(:exists?).returns "eh"
-            instance.exists?.should == "eh"
-        end
-    end
-
-    properties = [:ensure, :uid, :gid, :home, :comment, :shell, :password, :groups, :roles, :auths, :profiles, :project, :keys]
-
-    properties.each do |property|
-        it "should have a %s property" % property do
-            user.attrclass(property).ancestors.should be_include(Puppet::Property)
-        end
-
-        it "should have documentation for its %s property" % property do
-            user.attrclass(property).doc.should be_instance_of(String)
-        end
-    end
-
-    list_properties = [:groups, :roles, :auths]
-
-    list_properties.each do |property|
-        it "should have a list '%s'" % property do
-            user.attrclass(property).ancestors.should be_include(Puppet::Property::List)
-        end
-    end
-
-    it "should have an ordered list 'profiles'" do
-        user.attrclass(:profiles).ancestors.should be_include(Puppet::Property::OrderedList)
-    end
-
-    it "should have key values 'keys'" do
-        user.attrclass(:keys).ancestors.should be_include(Puppet::Property::KeyValue)
-    end
-
-    describe "when retrieving all current values" do
-        before do
-            @user = user.new(:name => "foo", :uid => 10)
-        end
-
-        it "should return a hash containing values for all set properties" do
-            @user[:gid] = 10
-            @user.property(:ensure).expects(:retrieve).returns :present
-            @user.property(:uid).expects(:retrieve).returns 15
-            @user.property(:gid).expects(:retrieve).returns 15
-            values = @user.retrieve
-            [@user.property(:uid), @user.property(:gid)].each { |property| values.should be_include(property) }
-        end
-
-        it "should set all values to :absent if the user is absent" do
-            @user.property(:ensure).expects(:retrieve).returns :absent
-            @user.property(:uid).expects(:retrieve).never
-            @user.retrieve[@user.property(:uid)].should == :absent
-        end
-
-        it "should include the result of retrieving each property's current value if the user is present" do
-            @user.property(:ensure).expects(:retrieve).returns :present
-            @user.property(:uid).expects(:retrieve).returns 15
-            @user.retrieve[@user.property(:uid)].should == 15
-        end
-    end
-
-    describe "when managing the ensure property" do
-        before do
-            @ensure = user.attrclass(:ensure).new(:resource => @resource)
-        end
-
-        it "should support a :present value" do
-            lambda { @ensure.should = :present }.should_not raise_error
-        end
-
-        it "should support an :absent value" do
-            lambda { @ensure.should = :absent }.should_not raise_error
-        end
-
-        it "should call :create on the provider when asked to sync to the :present state" do
-            @provider.expects(:create)
-            @ensure.should = :present
-            @ensure.sync
-        end
-
-        it "should call :delete on the provider when asked to sync to the :absent state" do
-            @provider.expects(:delete)
-            @ensure.should = :absent
-            @ensure.sync
-        end
-
-        describe "and determining the current state" do
-            it "should return :present when the provider indicates the user exists" do
-                @provider.expects(:exists?).returns true
-                @ensure.retrieve.should == :present
-            end
-
-            it "should return :absent when the provider indicates the user does not exist" do
-                @provider.expects(:exists?).returns false
-                @ensure.retrieve.should == :absent
-            end
-        end
-    end
-
-    describe "when managing the uid property" do
-        it "should convert number-looking strings into actual numbers" do
-            uid = user.attrclass(:uid).new(:resource => @resource)
-            uid.should = "50"
-            uid.should.must == 50
-        end
-
-        it "should support UIDs as numbers" do
-            uid = user.attrclass(:uid).new(:resource => @resource)
-            uid.should = 50
-            uid.should.must == 50
-        end
-
-        it "should :absent as a value" do
-            uid = user.attrclass(:uid).new(:resource => @resource)
-            uid.should = :absent
-            uid.should.must == :absent
-        end
-    end
-
-    describe "when managing the gid" do
-        it "should :absent as a value" do
-            gid = user.attrclass(:gid).new(:resource => @resource)
-            gid.should = :absent
-            gid.should.must == :absent
-        end
-
-        it "should convert number-looking strings into actual numbers" do
-            gid = user.attrclass(:gid).new(:resource => @resource)
-            gid.should = "50"
-            gid.should.must == 50
-        end
-
-        it "should support GIDs specified as integers" do
-            gid = user.attrclass(:gid).new(:resource => @resource)
-            gid.should = 50
-            gid.should.must == 50
-        end
-
-        it "should support groups specified by name" do
-            gid = user.attrclass(:gid).new(:resource => @resource)
-            gid.should = "foo"
-            gid.should.must == "foo"
-        end
-
-        describe "when testing whether in sync" do
-            before do
-                @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
-            end
-
-            it "should return true if no 'should' values are set" do
-                @gid = user.attrclass(:gid).new(:resource => @resource)
-
-                @gid.must be_insync(500)
-            end
-
-            it "should return true if any of the specified groups are equal to the current integer" do
-                Puppet::Util.expects(:gid).with("foo").returns 300
-                Puppet::Util.expects(:gid).with("bar").returns 500
-
-                @gid.must be_insync(500)
-            end
-
-            it "should return false if none of the specified groups are equal to the current integer" do
-                Puppet::Util.expects(:gid).with("foo").returns 300
-                Puppet::Util.expects(:gid).with("bar").returns 500
-
-                @gid.should_not be_insync(700)
-            end
-        end
-
-        describe "when syncing" do
-            before do
-                @gid = user.attrclass(:gid).new(:resource => @resource, :should => %w{foo bar})
-            end
-
-            it "should use the first found, specified group as the desired value and send it to the provider" do
-                Puppet::Util.expects(:gid).with("foo").returns nil
-                Puppet::Util.expects(:gid).with("bar").returns 500
-
-                @provider.expects(:gid=).with 500
-
-                @gid.sync
-            end
-        end
-    end
-
-    describe "when managing passwords" do
-        before do
-            @password = user.attrclass(:password).new(:resource => @resource, :should => "mypass")
-        end
-
-        it "should not include the password in the change log when adding the password" do
-            @password.change_to_s(:absent, "mypass").should_not be_include("mypass")
-        end
-
-        it "should not include the password in the change log when changing the password" do
-            @password.change_to_s("other", "mypass").should_not be_include("mypass")
-        end
-
-        it "should fail if a ':' is included in the password" do
-            lambda { @password.should = "some:thing" }.should raise_error(Puppet::Error)
-        end
-
-        it "should allow the value to be set to :absent" do
-            lambda { @password.should = :absent }.should_not raise_error
-        end
-    end
-
-    describe "when manages_solaris_rbac is enabled" do
-        before do
-            @provider.stubs(:satisfies?).returns(false)
-            @provider.expects(:satisfies?).with(:manages_solaris_rbac).returns(true)
-        end
-
-        it "should support a :role value for ensure" do
-            @ensure = user.attrclass(:ensure).new(:resource => @resource)
-            lambda { @ensure.should = :role }.should_not raise_error
-        end
-    end
-
-    describe "when user has roles" do
-        it "should autorequire roles" do
-            #this is a little funky because the autorequire depends on a property with a feature
-            testuser = Puppet::Type.type(:user).new(:name => "testuser")
-            testuser.provider.class.expects(:feature?).with(:manages_solaris_rbac).returns(true)
-            testuser[:roles] = "testrole"
-
-            testrole = Puppet::Type.type(:user).new(:name => "testrole")
-
-            config = Puppet::Resource::Catalog.new :testing do |conf|
-                [testuser, testrole].each { |resource| conf.add_resource resource }
-            end
-            Puppet::Type::User::ProviderDirectoryservice.stubs(:get_macosx_version_major).returns "10.5"
-
-            rel = testuser.autorequire[0]
-            rel.source.ref.should == testrole.ref
-            rel.target.ref.should == testuser.ref
-        end
-    end
-end

data/spec/unit/type/zfs.rb

@@ -1,45 +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") }
-
-zfs = Puppet::Type.type(:zfs)
-
-describe zfs do
-    properties = [:ensure, :mountpoint, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir]
-
-    properties.each do |property|
-        it "should have a %s property" % property do
-            zfs.attrclass(property).ancestors.should be_include(Puppet::Property)
-        end
-    end
-
-    parameters = [:name]
-
-    parameters.each do |parameter|
-        it "should have a %s parameter" % parameter do
-            zfs.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
-        end
-    end
-
-    it "should autorequire the containing zfss and the zpool" do
-        provider = mock "provider"
-        provider.stubs(:name).returns(:solaris)
-        zfs.stubs(:defaultprovider).returns(provider)
-        Puppet::Type.type(:zpool).stubs(:defaultprovider).returns(provider)
-
-
-        foo_pool = Puppet::Type.type(:zpool).new(:name => "foo")
-
-        foo_bar_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar")
-        foo_bar_baz_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar/baz")
-        foo_bar_baz_buz_zfs = Puppet::Type.type(:zfs).new(:name => "foo/bar/baz/buz")
-
-        config = Puppet::Resource::Catalog.new :testing do |conf|
-            [foo_pool, foo_bar_zfs, foo_bar_baz_zfs, foo_bar_baz_buz_zfs].each { |resource| conf.add_resource resource }
-        end
-
-        req = foo_bar_baz_buz_zfs.autorequire.collect { |edge| edge.source.ref }
-
-        [foo_pool.ref, foo_bar_zfs.ref, foo_bar_baz_zfs.ref].each { |ref| req.include?(ref).should == true }
-    end
-end

data/spec/unit/type/zone.rb

@@ -1,20 +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") }
-
-zone = Puppet::Type.type(:zone)
-
-describe zone do
-    before do
-        @provider = stub 'provider'
-        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
-    end
-
-    parameters = [:create_args, :install_args]
-
-    parameters.each do |parameter|
-        it "should have a %s parameter" % parameter do
-            zone.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
-        end
-    end
-end

data/spec/unit/type/zpool.rb

@@ -1,110 +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") }
-
-zpool = Puppet::Type.type(:zpool)
-
-describe zpool do
-    before do
-        @provider = stub 'provider'
-        @resource = stub 'resource', :resource => nil, :provider => @provider, :line => nil, :file => nil
-    end
-
-    properties = [:ensure, :disk, :mirror, :raidz, :spare, :log]
-
-    properties.each do |property|
-        it "should have a %s property" % property do
-            zpool.attrclass(property).ancestors.should be_include(Puppet::Property)
-        end
-    end
-
-    parameters = [:pool, :raid_parity]
-
-    parameters.each do |parameter|
-        it "should have a %s parameter" % parameter do
-            zpool.attrclass(parameter).ancestors.should be_include(Puppet::Parameter)
-        end
-    end
-end
-
-vdev_property = Puppet::Property::VDev
-
-describe vdev_property do
-    before do
-        vdev_property.initvars
-        @resource = stub 'resource', :[]= => nil, :property => nil
-        @property = vdev_property.new(:resource => @resource)
-    end
-
-    it "should be insync if the devices are the same" do
-        @property.should = ["dev1 dev2"]
-        @property.insync?(["dev2 dev1"]).must be_true
-    end
-
-    it "should be out of sync if the devices are not the same" do
-        @property.should = ["dev1 dev3"]
-        @property.insync?(["dev2 dev1"]).must be_false
-    end
-
-    it "should be insync if the devices are the same and the should values are comma seperated" do
-        @property.should = ["dev1", "dev2"]
-        @property.insync?(["dev2 dev1"]).must be_true
-    end
-
-    it "should be out of sync if the device is absent and should has a value" do
-        @property.should = ["dev1", "dev2"]
-        @property.insync?(:absent).must be_false
-    end
-
-    it "should be insync if the device is absent and should is absent" do
-        @property.should = [:absent]
-        @property.insync?(:absent).must be_true
-    end
-end
-
-multi_vdev_property = Puppet::Property::MultiVDev
-
-describe multi_vdev_property do
-    before do
-        multi_vdev_property.initvars
-        @resource = stub 'resource', :[]= => nil, :property => nil
-        @property = multi_vdev_property.new(:resource => @resource)
-    end
-
-    it "should be insync if the devices are the same" do
-        @property.should = ["dev1 dev2"]
-        @property.insync?(["dev2 dev1"]).must be_true
-    end
-
-    it "should be out of sync if the devices are not the same" do
-        @property.should = ["dev1 dev3"]
-        @property.insync?(["dev2 dev1"]).must be_false
-    end
-
-    it "should be out of sync if the device is absent and should has a value" do
-        @property.should = ["dev1", "dev2"]
-        @property.insync?(:absent).must be_false
-    end
-
-    it "should be insync if the device is absent and should is absent" do
-        @property.should = [:absent]
-        @property.insync?(:absent).must be_true
-    end
-
-    describe "when there are multiple lists of devices" do
-        it "should be in sync if each group has the same devices" do
-            @property.should = ["dev1 dev2", "dev3 dev4"]
-            @property.insync?(["dev2 dev1", "dev3 dev4"]).must be_true
-        end
-
-        it "should be out of sync if any group has the different devices" do
-            @property.should = ["dev1 devX", "dev3 dev4"]
-            @property.insync?(["dev2 dev1", "dev3 dev4"]).must be_false
-        end
-
-        it "should be out of sync if devices are in the wrong group" do
-            @property.should = ["dev1 dev2", "dev3 dev4"]
-            @property.insync?(["dev2 dev3", "dev1 dev4"]).must be_false
-        end
-    end
-end