diff --git a/lib/puppet/type/logical_volume.rb b/lib/puppet/type/logical_volume.rb index 3bebb924..9ce95335 100644 --- a/lib/puppet/type/logical_volume.rb +++ b/lib/puppet/type/logical_volume.rb @@ -99,7 +99,7 @@ def insync?(is) newparam(:stripes) do desc "The number of stripes to allocate for the new logical volume." validate do |value| - unless value =~ /^[0-9]+/i + unless value.to_s =~ /^[0-9]+$/i raise ArgumentError , "#{value} is not a valid stripe count" end end @@ -108,7 +108,7 @@ def insync?(is) newparam(:stripesize) do desc "The stripesize to use for the new logical volume." validate do |value| - unless value =~ /^[0-9]+/i + unless value.to_s =~ /^[0-9]+$/i raise ArgumentError , "#{value} is not a valid stripesize" end end @@ -117,7 +117,7 @@ def insync?(is) newparam(:readahead) do desc "The readahead count to use for the new logical volume." validate do |value| - unless value =~ /^([0-9]+|Auto|None)/i + unless value.to_s =~ /^([0-9]+|Auto|None)/i raise ArgumentError , "#{value} is not a valid readahead count" end end @@ -158,7 +158,7 @@ def insync?(is) newparam(:region_size) do desc "A mirror is divided into regions of this size (in MB), the mirror log uses this granularity to track which regions are in sync. CAN NOT BE CHANGED on already mirrored volume. Take your mirror size in terabytes and round up that number to the next power of 2, using that number as the -R argument." validate do |value| - unless value =~ /^[0-9]+/i + unless value.to_s =~ /^[0-9]+$/i raise ArgumentError , "#{value} is not a valid region size in MB." end end diff --git a/spec/unit/type/filesystem_spec.rb b/spec/unit/type/filesystem_spec.rb new file mode 100644 index 00000000..6390fd55 --- /dev/null +++ b/spec/unit/type/filesystem_spec.rb @@ -0,0 +1,31 @@ +require 'spec_helper' + +describe Puppet::Type.type(:filesystem) do + + it 'raises an ArgumentError when the name is not an absolute path' do + expect { + resource = Puppet::Type.type(:filesystem).new( + { + :name => 'notAnAbsolutePath', + :ensure => :present, + :fs_type => 'ext3', + :options => '-b 4096 -E stride=32,stripe-width=64', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter name failed on Filesystem[notAnAbsolutePath]: Filesystem names must be fully qualified') + end + + it 'does not raise an ArgumentError when the name is an absolute path' do + expect { + resource = Puppet::Type.type(:filesystem).new( + { + :name => '/dev/myvg/mylv', + :ensure => :present, + :fs_type => 'ext3', + :options => '-b 4096 -E stride=32,stripe-width=64', + } + ) + }.to_not raise_error + end +end diff --git a/spec/unit/type/logical_volume_spec.rb b/spec/unit/type/logical_volume_spec.rb new file mode 100644 index 00000000..deb649c6 --- /dev/null +++ b/spec/unit/type/logical_volume_spec.rb @@ -0,0 +1,433 @@ +require 'spec_helper' + +describe Puppet::Type.type(:logical_volume) do + it 'raises an ArgumentError when the name has a file separator' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => '/dev/lol', + :ensure => :present, + :volume_group => 'myvg', + :size => '20G', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter name failed on Logical_volume[/dev/lol]: Volume names must be entirely unqualified') + end + + it 'does not raise an ArgumentError when the name has no file separator' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :size => '20G', + } + ) + }.to_not raise_error + end + + it 'invalid logical initial volume size raises error (char)' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :initial_size => 'abcd', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter initial_size failed on Logical_volume[myvg]: abcd is not a valid logical volume size') + end + + it 'invalid logical initial volume size raises error (suffix)' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :initial_size => '20A', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter initial_size failed on Logical_volume[myvg]: 20A is not a valid logical volume size') + end + + it 'valid logical volume initial size does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :initial_size => '20G', + } + ) + }.to_not raise_error + end + + it 'invalid logical volume size raises error (char)' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :size => 'lucy<3', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter size failed on Logical_volume[myvg]: lucy<3 is not a valid logical volume size') + end + + it 'invalid logical volume size raises error (suffix)' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'myvg', + :ensure => :present, + :volume_group => 'myvg', + :size => '20Q', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter size failed on Logical_volume[myvg]: 20Q is not a valid logical volume size') + end + + it 'invalid logical volume extent raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'zerocool', + :ensure => :present, + :volume_group => 'myvg', + :size => '10M', + :extents => 'acidburn', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter extents failed on Logical_volume[zerocool]: acidburn is not a valid logical volume extent') + end + + it 'valid logical volume extent does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'zerocool', + :ensure => :present, + :volume_group => 'myvg', + :size => '10M', + :extents => '1%vg', + } + ) + }.to_not raise_error + end + + it 'persistent which is not true or false raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'simba', + :ensure => :present, + :volume_group => 'rafiki', + :size => '10M', + :persistent => 'nala', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter persistent failed on Logical_volume[simba]: persistent must be either be true or false') + end + + it 'persistent is true does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'simba', + :ensure => :present, + :volume_group => 'rafiki', + :size => '10M', + :persistent => :true, + } + ) + }.to_not raise_error + end + + it 'minor not set to integer between 0 and 255 raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'ringo', + :ensure => :present, + :volume_group => 'george', + :size => '10M', + :minor => '910' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter minor failed on Logical_volume[ringo]: 910 is not a valid value for minor. It must be an integer between 0 and 255') + end + + it 'minor set to integer between 0 and 255 does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'ringo', + :ensure => :present, + :volume_group => 'george', + :size => '10M', + :minor => '1' + } + ) + }.to_not raise_error + end + + it 'range set outside of valid range raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'john', + :ensure => :present, + :volume_group => 'paul', + :size => '10M', + :range => 'pete best' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter range failed on Logical_volume[john]: pete best is not a valid range') + end + + it 'range set within valid range does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'john', + :ensure => :present, + :volume_group => 'paul', + :size => '10M', + :range => 'minimum' + } + ) + }.to_not raise_error + end + + it 'invalid number of stripes raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'bert', + :ensure => :present, + :volume_group => 'ernie', + :size => '10M', + :stripes => 'rubber duckie' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter stripes failed on Logical_volume[bert]: rubber duckie is not a valid stripe count') + end + + it 'number of stripes which is a positive integer does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'big bird', + :ensure => :present, + :volume_group => 'elmo', + :size => '10M', + :stripes => '7' + } + ) + }.to_not raise_error + end + + it 'invalid stripesize raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'bert', + :ensure => :present, + :volume_group => 'ernie', + :size => '10M', + :stripesize => 'rubber duckie' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter stripesize failed on Logical_volume[bert]: rubber duckie is not a valid stripesize') + end + + it 'invalid stripesize raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'bert', + :ensure => :present, + :volume_group => 'ernie', + :size => '10M', + :stripesize => '7+' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter stripesize failed on Logical_volume[bert]: 7+ is not a valid stripesize') + end + + it 'valid stripesize does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'big bird', + :ensure => :present, + :volume_group => 'elmo', + :size => '10M', + :stripesize => '7' + } + ) + }.to_not raise_error + end + + it 'valid, unstringified stripesize does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'big bird', + :ensure => :present, + :volume_group => 'elmo', + :size => '10M', + :stripesize => 7 + } + ) + }.to_not raise_error + end + + it 'invalid readahead raises error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'bert', + :ensure => :present, + :volume_group => 'ernie', + :size => '10M', + :readahead => 'cookie monster' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter readahead failed on Logical_volume[bert]: cookie monster is not a valid readahead count') + end + + it 'valid readahead does not raise error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'bert', + :ensure => :present, + :volume_group => 'ernie', + :size => '10M', + :readahead => '7Auto' + } + ) + }.to_not raise_error + end + + it 'size is minsize raises error if not a boolean' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'kuzco', + :ensure => :present, + :volume_group => 'kronk', + :size => '10M', + :size_is_minsize => 'pacha', + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter size_is_minsize failed on Logical_volume[kuzco]: size_is_minsize must either be true or false') + end + + it 'size is minsize does not raise error if boolean' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'kuzco', + :ensure => :present, + :volume_group => 'kronk', + :size => '10M', + :size_is_minsize => 'true' + } + ) + }.to_not raise_error + end + + it 'mirror number outside of 0-4 range throws error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'scooby doo', + :ensure => :present, + :volume_group => 'shaggy', + :size => '10M', + :mirror => '-1' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter mirror failed on Logical_volume[scooby doo]: -1 is not a valid number of mirror copies. Use 0 to un-mirror or 1-4 to set up mirroring.') + end + + it 'mirror within 0-4 range does not throw error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'fred', + :ensure => :present, + :volume_group => 'daphne', + :size => '10M', + :mirror => '1' + } + ) + }.to_not raise_error + end + + it 'region_size with invalid value throws error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'fred', + :ensure => :present, + :volume_group => 'daphne', + :size => '10M', + :region_size => 'velma' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter region_size failed on Logical_volume[fred]: velma is not a valid region size in MB.') + end + + it 'region_size with invalid value throws error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'fred', + :ensure => :present, + :volume_group => 'daphne', + :size => '10M', + :region_size => '7+' + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter region_size failed on Logical_volume[fred]: 7+ is not a valid region size in MB.') + end + + it 'region_size set to positive integer does not throw error' do + expect { + resource = Puppet::Type.type(:logical_volume).new( + { + :name => 'fred', + :ensure => :present, + :volume_group => 'daphne', + :size => '10M', + :region_size => '910' + } + ) + }.to_not raise_error + end +end diff --git a/spec/unit/type/physical_volume.rb b/spec/unit/type/physical_volume.rb new file mode 100644 index 00000000..7d6fbf81 --- /dev/null +++ b/spec/unit/type/physical_volume.rb @@ -0,0 +1,50 @@ +require 'spec_helper' +describe Puppet::Type.type(:physical_volume) do + it 'raises an ArgumentError when the name is not fully qualified' do + expect { + resource = Puppet::Type.type(:physical_volume).new( + { + :name => 'nope', + :ensure => :present, + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter name failed on Physical_volume[nope]: Physical Volume names must be fully qualified') + end + + it 'does not raise an ArgumentError when the name is fully qualified' do + expect { + resource = Puppet::Type.type(:physical_volume).new( + { + :name => '/dev/lol', + :ensure => :present, + } + ) + }.to_not raise_error + end + + it 'raises an ArgumentError when the volume group name is invalid' do + expect { + resource = Puppet::Type.type(:physical_volume).new( + { + :name => '/dev/myvg', + :unless_vg => '!not@valid/group$name', + :ensure => :present, + } + ) + }.to raise_error(Puppet::ResourceError, + 'Parameter unless_vg failed on Physical_volume[/dev/myvg]: !not@valid/group$name is not a valid volume group name') + end + + it 'does not raise an ArgumentError when the volume group name is valid' do + expect { + resource = Puppet::Type.type(:physical_volume).new( + { + :name => '/dev/myvg', + :unless_vg => 'VALIDNAME123', + :ensure => :present, + } + ) + }.to_not raise_error + end +end