weasel_diesel 1.0.4 → 1.1.0

data/README.md

@@ -108,7 +108,131 @@ Or a more complex example using XML:
     end
 ```
 
-## JSON APIs
+## INPUT DSL
+
+As shown in the two examples above, input parameters can be:
+* optional or required
+* namespaced
+* typed
+* marked as not being null if passed
+* set to have a value defined in a list
+* set to have a min value
+* set to have a min length
+* set to have a max value
+* set to have a max length
+* documented
+
+Most of these settings are used to verify the input requests.
+
+### Supported defined types:
+
+* integer
+* float, decimal
+* string
+* boolean
+* array (comma delimited string)
+* binary, file
+
+#### Note regarding required vs optional params.
+
+You can't set a required param to be `:null => true`, if you do so, the
+setting will be ignored since all required params have to be present.
+
+If you set an optional param to be `:null => false`, the verification
+will only fail if the param was present in the request but the passed
+value is nil. You might want to use that setting if you have an optional
+param that, by definition isn't required but, if passed has to not be
+null.
+
+
+### Validation and other param options
+
+You can set many rules to define an input parameter.
+Here is a quick overview of the available param options, check the specs for more examples.
+Options can be combined.
+
+* `required` by default the defined optional input parameters are
+  optional. However their presence can be required by using this flag.
+  (Setting `:null => true` will be ignored if the paramter is required)
+  Example: `service.param.string :id, :required => true`
+* `in` or `options` limits the range of the possible values being
+  passed. Example: `service.param.string :skills, :options %w{ruby scala clojure}`
+* `default` sets a value for your in case you don't pass one. Example:
+  `service.param.datetime :timestamp, :default => Time.now`
+* `min_value` forces the param value to be equal or greater than the
+  option's value. Example: `service.param.integer :age, :min_value => 21
+* `max_value` forces the param value to be equal or less than the
+  options's value. Example: `service.param.integer :votes, :max_value => 7
+* `min_length` forces the length of the param value to be equal or
+  greater than the option's value. Example: `service.param.string :name, :min_length => 2`
+* `max_length` forces the length of the param value to be equal or
+  lesser than the options's value. Example: `service.param.string :name, :max_length => 251`
+* `null` in the case of an optional parameter, if the parameter is being
+  passed, the value can't be nil or empty.
+* `doc` document the param.
+
+### Namespaced/nested object
+
+Input parameters can be defined nested/namespaced.
+This is particuliarly frequent when using Rails for instance.
+
+```ruby
+service.params do |param|
+    param.string :framework, 
+      :in => ['RSpec', 'Bacon'],
+      :required => true,
+      :doc => "The test framework used, could be one of the two following: #{WeaselDieselSpecOptions.join(", ")}."
+
+    param.datetime :timestamp, :default => Time.now
+    param.string   :alpha,     :in      => ['a', 'b', 'c']
+    param.string   :version,   :null    => false, :doc => "The version of the framework to use."
+    param.integer  :num,       :min_value => 42,  :max_value => 1000, :doc => "The number to test"
+    param.string   :name,      :min_length => 5, :max_length => 25
+  end
+
+  service.params.namespace :user do |user|
+    user.integer :id, :required => :true
+    user.string  :sex, :in => %Q{female, male}
+    user.boolean :mailing_list, :default => true, :doc => "is the user subscribed to the ML?"
+    user.array   :skills, :in => %w{ruby js cooking}
+  end
+```
+
+
+
+Here is the same type of input but this time using a JSON jargon,
+`namespace` and `object` are aliases and can therefore can be used based
+on how the input type.
+
+```ruby
+# INPUT using 1.9 hash syntax
+service.params do |param|
+  param.integer :playlist_id,
+            doc: "The ID of the playlist to which the track belongs.",
+            required: true
+  param.object :track do |track|
+    track.string :title,
+                  doc: "The title of the track.",
+                  required: true
+    track.string :album_title,
+                  doc: "The title of the album to which the track belongs.",
+                  required: true
+    track.string :artist_name,
+                  doc: "The name of the track's artist.",
+                  required: true
+    track.string :rdio_id,
+                  doc: "The Rdio ID of the track.",
+                  required: true
+  end
+end
+```
+
+
+
+## OUTPUT DSL
+
+
+### JSON API example
 
 Consider the following JSON response:
 
@@ -164,28 +288,31 @@ JSON response validation can be done using an optional module as shown in
 The goal of this module is to help automate API testing by
 validating the data structure of the returned object.
 
+Another simple examples:
 
-Other JSON DSL examples:
-
+Actual output:
 ```
 {"organization": {"name": "Example"}}
 ```
 
+Output DSL:
 ``` Ruby
-  describe_service "example" do |service|
-    service.formats  :json
-    service.response do |response|
-      response.object :organization do |node|
-        node.string :name
-      end
+describe_service "example" do |service|
+  service.formats  :json
+  service.response do |response|
+    response.object :organization do |node|
+      node.string :name
     end
   end
+end
 ```
 
+Actual output:
 ``` 
  {"name": "Example"}
 ```
 
+Output DSL:
 ``` Ruby
 describe_service "example" do |service|
   service.formats  :json
@@ -198,8 +325,6 @@ end
 ```
 
 
-
-
 ## Test Suite & Dependencies
 
 The test suite requires Ruby 1.9.* along with `RSpec`, `Rack`, and `Sinatra` gems.

data/lib/params.rb

@@ -22,8 +22,11 @@ class WeaselDiesel
       # @option options [Symbol] :in A list of acceptable values.
       # @option options [Symbol] :options A list of acceptable values.
       # @option options [Symbol] :default The default value of the param.
-      # @option options [Symbol] :minvalue The minimum acceptable value.
-      # @option options [Symbol] :maxvalue The maximim acceptable value.
+      # @option options [Symbol] :min_value The minimum acceptable value.
+      # @option options [Symbol] :max_value The maximum acceptable value.
+      # @option options [Symbol] :min_length The minimum acceptable string length.
+      # @option options [Symbol] :max_length The maximum acceptable string length.
+      # @option options [Boolean] :null Can this value be null?
       # @option options [Symbol] :doc Documentation for the param.
       # @api public
       attr_reader :options
@@ -34,8 +37,11 @@ class WeaselDiesel
       # @option opts [Symbol] :in A list of acceptable values.
       # @option opts [Symbol] :options A list of acceptable values.
       # @option opts [Symbol] :default The default value of the param.
-      # @option opts [Symbol] :minvalue The minimum acceptable value.
-      # @option opts [Symbol] :maxvalue The maximim acceptable value.
+      # @option options [Symbol] :min_value The minimum acceptable value.
+      # @option options [Symbol] :max_value The maximum acceptable value.
+      # @option options [Symbol] :min_length The minimum acceptable string length.
+      # @option options [Symbol] :max_length The maximum acceptable string length.
+      # @option options [Boolean] :null Can this value be null?
       # @option opts [Symbol] :doc Documentation for the param.
       # @api public
       def initialize(name, opts = {})

data/lib/params_verification.rb

@@ -61,7 +61,7 @@ module ParamsVerification
     
     # Set optional defaults if any optional
     service_params.list_optional.each do |rule|
-      updated_params = run_optional_rule(rule, updated_params)
+      updated_params = validate_optional_rule(rule, updated_params)
     end
     
     # check the namespaced params
@@ -70,9 +70,8 @@ module ParamsVerification
         updated_params = validate_required_rule(rule, updated_params, param.space_name.to_s)
       end
       param.list_optional.each do |rule|
-        updated_params = run_optional_rule(rule, updated_params, param.space_name.to_s)
+        updated_params = validate_optional_rule(rule, updated_params, param.space_name.to_s)
       end
-
     end
     
     # verify nested params, only 1 level deep tho
@@ -90,7 +89,7 @@ module ParamsVerification
   
   private
   
-  # Validate a required rule against a list of params passed.
+  # Validates a required rule against a list of params passed.
   #
   #
   # @param [WeaselDiesel::Params::Rule] rule The required rule to check against.
@@ -103,56 +102,145 @@ module ParamsVerification
   # @api private
   def self.validate_required_rule(rule, params, namespace=nil)
     param_name  = rule.name.to_s
-    
     param_value, namespaced_params = extract_param_values(params, param_name, namespace)
-    # puts "verify #{param_name} params, current value: #{param_value}"
-    
-    #This is disabled since required params shouldn't have a default, otherwise, why are they required?
-    #if param_value.nil? && rule.options && rule.options[:default]
-      #param_value = rule.options[:default]
-    #end
 
     # Checks presence
     if !(namespaced_params || params).keys.include?(param_name)
       raise MissingParam, "'#{rule.name}' is missing - passed params: #{params.inspect}."
-    # checks null
-    elsif param_value.nil? && !rule.options[:null]
-      raise  InvalidParamValue, "Value for parameter '#{param_name}' is missing - passed params: #{params.inspect}."
-    # checks type
-    elsif rule.options[:type]
-      verify_cast(param_name, param_value, rule.options[:type])
     end
 
-    if rule.options[:options] || rule.options[:in.inspect]
-      choices = rule.options[:options] || rule.options[:in]
-      if rule.options[:type]
-        # Force the cast so we can compare properly
-        param_value = params[param_name] = type_cast_value(rule.options[:type], param_value)
+    updated_param_value, updated_params = validate_and_cast_type(param_value, param_name, rule.options[:type], params, namespace)
+
+    # check for nulls in params that don't allow them
+    if !valid_null_param?(param_name, updated_param_value, rule)
+      raise InvalidParamValue, "Value for parameter '#{param_name}' cannot be null - passed params: #{updated_params.inspect}."
+    elsif updated_param_value
+      value_errors = validate_ruled_param_value(param_name, updated_param_value, rule)
+      raise InvalidParamValue, value_errors.join(', ') if value_errors
+    end
+
+    updated_params
+  end
+
+
+  # Validates that an optional rule is respected.
+  # If the rule contains default values, the params might be updated.
+  #
+  # @param [#WeaselDiesel::Params::Rule] rule The optional rule
+  # @param [Hash] params The request params
+  # @param [String] namespace An optional namespace
+  #
+  # @return [Hash] The potentially modified params
+  # 
+  # @api private
+  def self.validate_optional_rule(rule, params, namespace=nil)
+    param_name  = rule.name.to_s
+    param_value, namespaced_params = extract_param_values(params, param_name, namespace)
+
+    if param_value && !valid_null_param?(param_name, param_value, rule)
+      raise InvalidParamValue, "Value for parameter '#{param_name}' cannot be null if passed - passed params: #{params.inspect}."
+    end
+
+    # Use a default value if one is available and the submitted param value is nil
+    if param_value.nil? && rule.options[:default]
+      param_value = rule.options[:default]
+      if namespace
+        params[namespace] ||= {}
+        params[namespace][param_name] = param_value
+      else
+        params[param_name] = param_value
       end
-      raise InvalidParamValue, "Value for parameter '#{param_name}' (#{param_value}) is not in the allowed set of values." unless choices.include?(param_value)
-    # You can have a "in" rule that also applies a min value since they are mutually exclusive
-    elsif rule.options[:minvalue]
-      min = rule.options[:minvalue]
-      raise InvalidParamValue, "Value for parameter '#{param_name}' is lower than the min accepted value (#{min})." if param_value.to_i < min
     end
-    # Returns the updated params
-    
-    # cast the type if a type is defined and if a range of options isn't defined since the casting should have been done already
-    if rule.options[:type] && !(rule.options[:options] || rule.options[:in])
-      # puts "casting #{param_value} into type: #{rule.options[:type]}"
-      params[param_name] = type_cast_value(rule.options[:type], param_value)
+
+    updated_param_value, updated_params = validate_and_cast_type(param_value, param_name, rule.options[:type], params, namespace)
+    value_errors = validate_ruled_param_value(param_name, updated_param_value, rule) if updated_param_value
+    raise InvalidParamValue, value_errors.join(', ') if value_errors
+
+    updated_params
+  end
+
+
+  # Validates the param value against the rule and cast the param in the appropriate type.
+  # The modified params containing the cast value is returned along the cast param value.
+  #
+  # @param [Object] param_value The value to validate and cast.
+  # @param [String] param_name The name of the param we are validating.
+  # @param [Symbol] type The expected object type.
+  # @param [Hash] params The params that might need to be updated.
+  # @param [String, Symbol] namespace The optional namespace used to access the `param_value`
+  #
+  # @return [Array<Object, Hash>] An array containing the param value and 
+  #   a hash representing the potentially modified params after going through the filter.
+  #
+  def self.validate_and_cast_type(param_value, param_name, rule_type, params, namespace=nil)
+    # checks type & modifies params if needed
+    if rule_type
+      verify_cast(param_name, param_value, rule_type)
+      param_value = type_cast_value(rule_type, param_value)
+      # update the params hash with the type cast value
+      if namespace
+        params[namespace] ||= {}
+        params[namespace][param_name] = param_value
+      else
+        params[param_name] = param_value
+      end
     end
-    params
+    [param_value, params]
   end
 
 
-  # Extract the param valie and the namespaced params
+  # Validates a value against a few rule options.
+  #
+  # @return [NilClass, Array<String>] Returns an array of error messages if an option didn't validate.
+  def self.validate_ruled_param_value(param_name, param_value, rule)
+
+    # checks the value against a whitelist style 'in'/'options' list
+    if rule.options[:options] || rule.options[:in]
+      choices = rule.options[:options] || rule.options[:in]
+      unless param_value.is_a?(Array) ? (param_value & choices == param_value) : choices.include?(param_value)
+        errors ||= []
+        errors << "Value for parameter '#{param_name}' (#{param_value}) is not in the allowed set of values."
+      end
+    end
+
+    # enforces a minimum numeric value
+    if rule.options[:min_value]
+      min = rule.options[:min_value]
+      errors ||= []
+      errors << "Value for parameter '#{param_name}' is lower than the min accepted value (#{min})." if param_value.to_i < min
+    end
+
+    # enforces a maximum numeric value
+    if rule.options[:max_value]
+      max = rule.options[:max_value]
+      errors ||= []
+      errors << "Value for parameter '#{param_name}' is higher than the max accepted value (#{max})." if param_value.to_i > max
+    end
+
+    # enforces a minimum string length
+    if rule.options[:min_length]
+      min = rule.options[:min_length]
+      errors ||= []
+      errors << "Length of parameter '#{param_name}' is shorter than the min accepted value (#{min})." if param_value.to_s.length < min
+    end
+
+    # enforces a maximum string length
+    if rule.options[:max_length]
+      max = rule.options[:max_length]
+      errors ||= []
+      errors << "Length of parameter '#{param_name}' is longer than the max accepted value (#{max})." if param_value.to_s.length > max
+    end
+
+    errors
+  end
+
+  # Extract the param value and the namespaced params
   # based on a passed namespace and params
   #
   # @param [Hash] params The passed params to extract info from.
   # @param [String] param_name The param name to find the value.
   # @param [NilClass, String] namespace the params' namespace.
-  # @return [Arrays<Object, String>]
+  # @return [Array<Object, String>]
   #
   # @api private
   def self.extract_param_values(params, param_name, namespace=nil)
@@ -170,41 +258,6 @@ module ParamsVerification
     end
   end
   
-  # @param [#WeaselDiesel::Params::Rule] rule The optional rule
-  # @param [Hash] params The request params
-  # @param [String] namespace An optional namespace
-  # @return [Hash] The potentially modified params
-  # 
-  # @api private
-  def self.run_optional_rule(rule, params, namespace=nil)
-    param_name  = rule.name.to_s
-
-    param_value, namespaced_params = extract_param_values(params, param_name, namespace)
-
-    if param_value.nil? && rule.options[:default]
-      if namespace
-        params[namespace][param_name] = param_value = rule.options[:default]
-      else
-        params[param_name] = param_value = rule.options[:default]
-      end
-    end
-    
-    # cast the type if a type is defined and if a range of options isn't defined since the casting should have been done already
-    if rule.options[:type] && !param_value.nil?
-      if namespace
-        params[namespace][param_name] = param_value = type_cast_value(rule.options[:type], param_value)
-      else
-        params[param_name] = param_value = type_cast_value(rule.options[:type], param_value)
-      end
-    end
-
-    choices = rule.options[:options] || rule.options[:in]
-    if choices && param_value && !choices.include?(param_value)
-      raise InvalidParamValue, "Value for parameter '#{param_name}' (#{param_value}) is not in the allowed set of values."
-    end
-    
-    params
-  end
   
   def self.unexpected_params?(params, param_names)
     # Raise an exception unless no unexpected params were found
@@ -216,6 +269,7 @@ module ParamsVerification
   
   
   def self.type_cast_value(type, value)
+    return value if value == nil
     case type
     when :integer
       value.to_i
@@ -241,30 +295,49 @@ module ParamsVerification
     # An array type is a comma delimited string, we need to cast the passed strings.
     when :array
       value.respond_to?(:split) ? value.split(',') : value
-    when :binary, :array, :file
+    when :binary, :file
       value
     else
       value
     end
   end
   
-  # Checks that the value's type matches the expected type for a given param
+  # Checks that the value's type matches the expected type for a given param. If a nil value is passed
+  # the verification is skipped.
   #
   # @param [Symbol, String] Param name used if the verification fails and that an error is raised.
-  # @param [#to_s] The value to validate.
+  # @param [NilClass, #to_s] The value to validate.
   # @param [Symbol] The expected type, such as :boolean, :integer etc...
   # @raise [InvalidParamType] Custom exception raised when the validation isn't found or the value doesn't match.
   #
-  # @return [Nil]
+  # @return [NilClass]
   # @api public
-  # TODO raising an exception really isn't a good idea since it forces the stack to unwind.
-  # More than likely developers are using exceptions to control the code flow and a different approach should be used.
-  # Catch/throw is a bit more efficient but is still the wrong approach for this specific problem.
   def self.verify_cast(name, value, expected_type)
+    return if value == nil
     validation = ParamsVerification.type_validations[expected_type.to_sym]
     unless validation.nil? || value.to_s =~ validation
       raise InvalidParamType, "Value for parameter '#{name}' (#{value}) is of the wrong type (expected #{expected_type})"
     end
   end
+
+  # Checks that a param explicitly set to not be null is present.
+  # if 'null' is found in the ruleset and set to 'false' (default is 'true' to allow null),
+  # then confirm that the submitted value isn't nil or empty
+  # @param [String] param_name The name of the param to verify.
+  # @param [NilClass, String, Integer, TrueClass, FalseClass] param_value The value to check.
+  # @param [WeaselDiesel::Params::Rule] rule The rule to check against.
+  #
+  # @return [Boolean] true if the param is valid, false otherwise
+  def self.valid_null_param?(param_name, param_value, rule)
+    if rule.options.has_key?(:null) && rule.options[:null] == false
+      if rule.options[:type] && rule.options[:type] == :array
+        return false if param_value.nil? || (param_value.respond_to?(:split) && param_value.split(',').empty?)
+      else
+        return false if param_value.nil? || param_value == ''
+      end
+    end
+    true
+  end
+
   
 end

data/lib/weasel_diesel/version.rb

@@ -1,3 +1,3 @@
 class WeaselDiesel
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

data/spec/params_verification_spec.rb

@@ -5,37 +5,67 @@ describe ParamsVerification do
   before :all do
     @service = WSList.all.find{|s| s.url == 'services/test.xml'}
     @service.should_not be_nil
-    @valid_params = {'framework' => 'RSpec', 'version' => '1.02', 'user' => {'id' => '123'}}
+    @valid_params = {'framework' => 'RSpec', 'version' => '1.02', 'user' => {'id' => '123', 'groups' => 'manager,developer', 'skills' => 'java,ruby'}}
+  end
+
+  def copy(params)
+    Marshal.load( Marshal.dump(params) )
   end
   
   it "should validate valid params" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should_not raise_exception
   end
   
   it "should return the params" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
     returned_params.should be_an_instance_of(Hash)
     returned_params.keys.size.should >= 3
   end
   
+  it "should return array in the params" do
+    params = copy(@valid_params)
+    returned_params = ParamsVerification.validate!(params, @service.defined_params)
+    returned_params['user']['groups'].should be == @valid_params['user']['groups'].split(",")
+    returned_params['user']['skills'].should be == @valid_params['user']['skills'].split(",")
+  end
+
+  it "should not duplicate params in the root level" do
+    params = copy(@valid_params)
+    returned_params = ParamsVerification.validate!(params, @service.defined_params)
+    returned_params['groups'].should be_nil
+    returned_params['skills'].should be_nil
+  end
+
+  it "should raise an exception when values of required param are not in the allowed list" do
+    params = copy(@valid_params)
+    params['user']['groups'] = 'admin,root,manager'
+    lambda { ParamsVerification.validate!(params, @service.defined_params) }.should raise_error(ParamsVerification::InvalidParamValue)
+  end
+
+  it "should raise an exception when values of optional param are not in the allowed list" do
+    params = copy(@valid_params)
+    params['user']['skills'] = 'ruby,java,php'
+    lambda { ParamsVerification.validate!(params, @service.defined_params) }.should raise_error(ParamsVerification::InvalidParamValue)
+  end
+
   it "should set the default value for an optional param" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params['timestamp'].should be_nil
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
     returned_params['timestamp'].should_not be_nil
   end
 
   it "should set the default value for a namespace optional param" do
-    params = {'framework' => 'RSpec', 'version' => '1.02', 'user' => {'id' => '123'}}
+    params = copy(@valid_params)
     params['user']['mailing_list'].should be_nil
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
     returned_params['user']['mailing_list'].should be_true
   end
   
   it "should raise an exception when a required param is missing" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params.delete('framework')
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::MissingParam)
   end
@@ -55,27 +85,47 @@ describe ParamsVerification do
   end
   
   it "should raise an exception when a param is of the wrong type" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params['user']['id'] = 'abc'
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamType)
   end
   
-  it "should raise an exception when a param is under the minvalue" do
-    params = @valid_params.dup
+  it "should raise an exception when a param is under the min_value" do
+    params = copy(@valid_params)
+    params['num'] = '1'
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
     params['num'] = 1
-    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamType)
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
+  end
+
+  it "should raise an exception when a param is over the max_value" do
+    params = copy(@valid_params)
+    params['num'] = 10_000
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
+  end
+
+  it "should raise an exception when a param is under the min_length" do
+    params = copy(@valid_params)
+    params['name'] ='bob'
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
+  end
+
+  it "should raise an exception when a param is over the max_length" do
+    params = copy(@valid_params)
+    params['name'] = "Whether 'tis nobler in the mind to suffer The slings and arrows of outrageous fortune"
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
   end
   
   it "should raise an exception when a param isn't in the param option list" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params['alpha'] = 'z'
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
   end
 
   it "should raise an exception when a nested optional param isn't in the param option list" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params['user']['sex'] = 'large'
-    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamType)
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
     # other service
     params = {'preference' => {'region_code' => 'us', 'language_code' => 'de'}}
     service = WSList.all.find{|s| s.url == 'preferences.xml'}
@@ -91,25 +141,34 @@ describe ParamsVerification do
     lambda{ ParamsVerification.validate!(params, service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
   end
 
-  
   it "should validate that no params are passed when accept_no_params! is set on a service" do
     service = WSList.all.find{|s| s.url == "services/test_no_params.xml"}
     service.should_not be_nil
-    params = @valid_params.dup
+    params = copy(@valid_params)
     lambda{ ParamsVerification.validate!(params, service.defined_params) }.should raise_exception
   end
 
   it "should raise an exception when an unexpected param is found" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params['attack'] = true
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::UnexpectedParam)
   end
 
   it "should prevent XSS attack on unexpected param name being listed in the exception message" do
-    params = @valid_params.dup
+    params = copy(@valid_params)
     params["7e22c<script>alert('xss vulnerability')</script>e88ff3f0952"] = 1
     escaped_error_message = /7e22c&lt;script&gt;alert\('xss vulnerability'\)&lt;\/script&gt;e88ff3f0952/
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::UnexpectedParam, escaped_error_message)
   end
+
+  it "should make sure that optional params marked as not false are being set" do
+    params = copy(@valid_params)
+    ParamsVerification.validate!(params, @service.defined_params).should be_true
+    params.delete('version')
+    # if omitted, the param should not raise an exception
+    ParamsVerification.validate!(params, @service.defined_params).should be_true
+    params['version'] = ''
+    lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
+  end
   
 end

data/spec/test_services.rb

@@ -16,8 +16,8 @@ describe_service "services/test.xml" do |service|
     p.datetime :timestamp, :default => Time.now
     p.string   :alpha,     :in      => ['a', 'b', 'c']
     p.string   :version,   :null    => false, :doc => "The version of the framework to use."
-    p.integer  :num,       :minvalue => 42,            :doc => "The number to test"
-
+    p.integer  :num,       :min_value => 42,  :max_value => 1000, :doc => "The number to test"
+    p.string   :name,      :min_length => 5, :max_length => 25
   end
 
   # service.param :delta, :optional => true, :type => 'float'
@@ -26,8 +26,10 @@ describe_service "services/test.xml" do |service|
 
   service.params.namespace :user do |user|
     user.integer :id, :required => :true
-    user.string :sex, :in => %Q{female, male}
+    user.string  :sex, :in => %Q{female, male}
     user.boolean :mailing_list, :default => true, :doc => "is the user subscribed to the ML?"
+    user.array   :groups, :required => true, :in => %w{developer admin manager}
+    user.array   :skills, :in => %w{ruby java networking}
   end
 
   # the response contains a list of player creation ratings each object in the list

data/spec/wd_params_spec.rb

@@ -21,7 +21,7 @@ describe WeaselDiesel::Params do
 
   it "should have a list of optional param rules" do
     @sparams.list_optional.should be_an_instance_of(Array)
-    @sparams.list_optional.length.should == 4
+    @sparams.list_optional.length.should == 5
   end
 
   it "should have a list of namespaced param rules" do

metadata

@@ -1,131 +1,103 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: weasel_diesel
-version: !ruby/object:Gem::Version 
-  hash: 31
+version: !ruby/object:Gem::Version
+  version: 1.1.0
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 4
-  version: 1.0.4
 platform: ruby
-authors: 
+authors:
 - Matt Aimonetti
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-05-24 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rack-test
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: sinatra
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: backports
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: json
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id007
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby DSL describing Web Services without implementation details.
-email: 
+email:
 - mattaimonetti@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
@@ -158,41 +130,31 @@ files:
 - spec/ws_list_spec.rb
 - spec/wsdsl_sinatra_ext_spec.rb
 - weasel_diesel.gemspec
-has_rdoc: true
 homepage: https://github.com/mattetti/Weasel-Diesel
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: wsdsl
-rubygems_version: 1.5.3
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Web Service DSL
-test_files: 
+test_files:
 - spec/hello_world_controller.rb
 - spec/hello_world_service.rb
 - spec/json_response_description_spec.rb
@@ -207,3 +169,4 @@ test_files:
 - spec/wd_spec.rb
 - spec/ws_list_spec.rb
 - spec/wsdsl_sinatra_ext_spec.rb
+has_rdoc: