module Helpers TEST_DIR = Pathname.new(__FILE__).parent + '..' TYPES = { :ec2 => :ec2 } def self.included(obj) obj.instance_eval { attr_accessor :valid_params } end # self is available at the describe level def restricted_params(key, params, opts={}, invalid='invalid') params.each do |param| #let(:param) {param} #let(:key) {key} with(valid_params_with({key => param}))[key].should == param end lambda {with(valid_params_with({key => invalid}))}.should raise_error end # test that a list of attributes are required def should_require(*keys) keys.each do |k| lambda { with(valid_params_without(k)) }.should raise_error Puppet::Error end end # tests that an attribute should accept a value def should_accept(attr, value) k=attr.to_sym with(valid_params_with({k => value}))[k].should == value end # tests that an attribute should not accept a value def should_not_accept(attr, value) k=attr.to_sym lambda {with(valid_params_with({k => value}))}.should raise_error Puppet::Error end # tests that an attribute accepts an array # - single element array, multiple element array # - string is converted into an array def should_accept_array(attr, value=['one', 'two']) should_accept(attr, value) should_accept(attr, value.first.to_a ) with(valid_params_with({attr => value.first}))[attr].should == value.first.to_a end # test that an attribute defaults to a value def should_default_to(attr, defaultto) with(valid_params_without(attr.to_sym))[:comment].should == defaultto end # Creates a new resource of +type+ def with(opts = {}, &block) resource = @type.new(opts) block ? (yield resource) : resource end # what is the difference? # Returns a lambda creating a resource (ready for use with +should+) def specifying(opts = {}, &block) specification = lambda { with(opts) } block ? (yield specification) : specification end # Sets up an expection that a resource for +type+ is not created def should_not_create(type) raise "Invalid type #{type}" unless TYPES[type] Puppet::Type.type(TYPES[type]).expects(:new).never end # Sets up an expection that a resource for +type+ is created def should_create(type) raise "Invalid type #{type}" unless TYPES[type] Puppet::Type.type(TYPES[type]).expects(:new).with { |args| yield(args) } end # Return the +@valid_params+ without one or more keys # Note: Useful since resource types don't like it when +nil+ is # passed as a parameter value def valid_params_without(*keys) valid_params.reject { |k, v| keys.include?(k) } end # yeah! I added this one! def valid_params_with(opts = {}) opts.each { |k, v| valid_params[k] = v} valid_params end # Stub the default provider to get around confines for testing def stub_default_provider!(name) unless defined?(@type) raise ArgumentError, "@type must be set" end provider = @type.provider(name.to_sym) @type.stubs(:defaultprovider => provider) end def fixture(name, ext = '.txt') (TEST_DIR + 'fixtures' + "#{name}#{ext}").read end end #Spec::Example::ExampleGroupFactory.register(:provider, ProviderExampleGroup) # # Outside wrapper to lookup a provider and start the spec using ProviderExampleGroup #def describe_provider(type_name, provider_name, options = {}, &block) # provider_class = Puppet::Type.type(type_name).provider(provider_name) # describe(provider_class, options.merge(:type => :provider), &block) #end