jro_apps/redmine Commit - r8974:dc50edae5e27

Adds a template for API error messages so that it does not depend on AR::Errors serialization....

Jean-Philippe Lang -

r8974:dc50edae5e27

parent child

Context file:

r8974:dc50edae5e27

Collapse all files

app/views/common/error_messages.api.rsb created 644 +5 0

@@ -0,0 +1,5
	1	api.array :errors do
	2	@error_messages.each do \|message\|
	3	api.error message
	4	end
	5	end

app/controllers/application_controller.rb +2 -9

             # Redmine - project management software
             # Copyright (C) 2006-2011  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'uri'
             require 'cgi'
             class Unauthorized < Exception; end
             class ApplicationController < ActionController::Base
               include Redmine::I18n
               layout 'base'
               exempt_from_layout 'builder', 'rsb'
               protect_from_forgery
               def handle_unverified_request
                 super
                 cookies.delete(:autologin)
               end
               # Remove broken cookie after upgrade from 0.8.x (#4292)
               # See https://rails.lighthouseapp.com/projects/8994/tickets/3360
               # TODO: remove it when Rails is fixed
               before_filter :delete_broken_cookies
               def delete_broken_cookies
                 if cookies['_redmine_session'] && cookies['_redmine_session'] !~ /--/
                   cookies.delete '_redmine_session'
                   redirect_to home_path
                   return false
                 end
               end
               # FIXME: Remove this when all of Rack and Rails have learned how to
               # properly use encodings
               before_filter :params_filter
               def params_filter
                 if RUBY_VERSION >= '1.9' && defined?(Rails) && Rails::VERSION::MAJOR < 3
                   self.utf8nize!(params)
                 end
               end
               def utf8nize!(obj)
                 if obj.frozen?
                   obj
                 elsif obj.is_a? String
                   obj.respond_to?(:force_encoding) ? obj.force_encoding("UTF-8") : obj
                 elsif obj.is_a? Hash
                   obj.each {|k, v| obj[k] = self.utf8nize!(v)}
                 elsif obj.is_a? Array
                   obj.each {|v| self.utf8nize!(v)}
                 else
                   obj
                 end
               end
               before_filter :user_setup, :check_if_login_required, :set_localization
               filter_parameter_logging :password
               rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token
               rescue_from ::Unauthorized, :with => :deny_access
               include Redmine::Search::Controller
               include Redmine::MenuManager::MenuController
               helper Redmine::MenuManager::MenuHelper
               Redmine::Scm::Base.all.each do |scm|
                 require_dependency "repository/#{scm.underscore}"
               end
               def user_setup
                 # Check the settings cache for each request
                 Setting.check_cache
                 # Find the current user
                 User.current = find_current_user
               end
               # Returns the current user or nil if no user is logged in
               # and starts a session if needed
               def find_current_user
                 if session[:user_id]
                   # existing session
                   (User.active.find(session[:user_id]) rescue nil)
                 elsif cookies[:autologin] && Setting.autologin?
                   # auto-login feature starts a new session
                   user = User.try_to_autologin(cookies[:autologin])
                   session[:user_id] = user.id if user
                   user
                 elsif params[:format] == 'atom' && params[:key] && request.get? && accept_rss_auth?
                   # RSS key authentication does not start a session
                   User.find_by_rss_key(params[:key])
                 elsif Setting.rest_api_enabled? && accept_api_auth?
                   if (key = api_key_from_request)
                     # Use API key
                     User.find_by_api_key(key)
                   else
                     # HTTP Basic, either username/password or API key/random
                     authenticate_with_http_basic do |username, password|
                       User.try_to_login(username, password) || User.find_by_api_key(username)
                     end
                   end
                 end
               end
               # Sets the logged in user
               def logged_user=(user)
                 reset_session
                 if user && user.is_a?(User)
                   User.current = user
                   session[:user_id] = user.id
                 else
                   User.current = User.anonymous
                 end
               end
               # check if login is globally required to access the application
               def check_if_login_required
                 # no check needed if user is already logged in
                 return true if User.current.logged?
                 require_login if Setting.login_required?
               end
               def set_localization
                 lang = nil
                 if User.current.logged?
                   lang = find_language(User.current.language)
                 end
                 if lang.nil? && request.env['HTTP_ACCEPT_LANGUAGE']
                   accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first
                   if !accept_lang.blank?
                     accept_lang = accept_lang.downcase
                     lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
                   end
                 end
                 lang ||= Setting.default_language
                 set_language_if_valid(lang)
               end
               def require_login
                 if !User.current.logged?
                   # Extract only the basic url parameters on non-GET requests
                   if request.get?
                     url = url_for(params)
                   else
                     url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
                   end
                   respond_to do |format|
                     format.html { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.atom { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.xml  { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                     format.js   { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                     format.json { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                   end
                   return false
                 end
                 true
               end
               def require_admin
                 return unless require_login
                 if !User.current.admin?
                   render_403
                   return false
                 end
                 true
               end
               def deny_access
                 User.current.logged? ? render_403 : require_login
               end
               # Authorize the user for the requested action
               def authorize(ctrl = params[:controller], action = params[:action], global = false)
                 allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project || @projects, :global => global)
                 if allowed
                   true
                 else
                   if @project && @project.archived?
                     render_403 :message => :notice_not_authorized_archived_project
                   else
                     deny_access
                   end
                 end
               end
               # Authorize the user for the requested action outside a project
               def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
                 authorize(ctrl, action, global)
               end
               # Find project of id params[:id]
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find project of id params[:project_id]
               def find_project_by_project_id
                 @project = Project.find(params[:project_id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find a project based on params[:project_id]
               # TODO: some subclasses override this, see about merging their logic
               def find_optional_project
                 @project = Project.find(params[:project_id]) unless params[:project_id].blank?
                 allowed = User.current.allowed_to?({:controller => params[:controller], :action => params[:action]}, @project, :global => true)
                 allowed ? true : deny_access
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Finds and sets @project based on @object.project
               def find_project_from_association
                 render_404 unless @object.present?
                 @project = @object.project
               end
               def find_model_object
                 model = self.class.read_inheritable_attribute('model_object')
                 if model
                   @object = model.find(params[:id])
                   self.instance_variable_set('@' + controller_name.singularize, @object) if @object
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def self.model_object(model)
                 write_inheritable_attribute('model_object', model)
               end
               # Filter for bulk issue operations
               def find_issues
                 @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                 raise ActiveRecord::RecordNotFound if @issues.empty?
                 if @issues.detect {|issue| !issue.visible?}
                   deny_access
                   return
                 end
                 @projects = @issues.collect(&:project).compact.uniq
                 @project = @projects.first if @projects.size == 1
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # make sure that the user is a member of the project (or admin) if project is private
               # used as a before_filter for actions that do not require any particular permission on the project
               def check_project_privacy
                 if @project && @project.active?
                   if @project.visible?
                     true
                   else
                     deny_access
                   end
                 else
                   @project = nil
                   render_404
                   false
                 end
               end
               def back_url
                 params[:back_url] || request.env['HTTP_REFERER']
               end
               def redirect_back_or_default(default)
                 back_url = CGI.unescape(params[:back_url].to_s)
                 if !back_url.blank?
                   begin
                     uri = URI.parse(back_url)
                     # do not redirect user to another host or to the login or register page
                     if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
                       redirect_to(back_url)
                       return
                     end
                   rescue URI::InvalidURIError
                     # redirect to default
                   end
                 end
                 redirect_to default
                 false
               end
               def render_403(options={})
                 @project = nil
                 render_error({:message => :notice_not_authorized, :status => 403}.merge(options))
                 return false
               end
               def render_404(options={})
                 render_error({:message => :notice_file_not_found, :status => 404}.merge(options))
                 return false
               end
               # Renders an error response
               def render_error(arg)
                 arg = {:message => arg} unless arg.is_a?(Hash)
                 @message = arg[:message]
                 @message = l(@message) if @message.is_a?(Symbol)
                 @status = arg[:status] || 500
                 respond_to do |format|
                   format.html {
                     render :template => 'common/error', :layout => use_layout, :status => @status
                   }
                   format.atom { head @status }
                   format.xml { head @status }
                   format.js { head @status }
                   format.json { head @status }
                 end
               end
               # Filter for actions that provide an API response
               # but have no HTML representation for non admin users
               def require_admin_or_api_request
                 return true if api_request?
                 if User.current.admin?
                   true
                 elsif User.current.logged?
                   render_error(:status => 406)
                 else
                   deny_access
                 end
               end
               # Picks which layout to use based on the request
               #
               # @return [boolean, string] name of the layout to use or false for no layout
               def use_layout
                 request.xhr? ? false : 'base'
               end
               def invalid_authenticity_token
                 if api_request?
                   logger.error "Form authenticity token is missing or is invalid. API calls must include a proper Content-type header (text/xml or text/json)."
                 end
                 render_error "Invalid form authenticity token."
               end
               def render_feed(items, options={})
                 @items = items || []
                 @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                 @items = @items.slice(0, Setting.feeds_limit.to_i)
                 @title = options[:title] || Setting.app_title
                 render :template => "common/feed.atom", :layout => false,
                        :content_type => 'application/atom+xml'
               end
               # TODO: remove in Redmine 1.4
               def self.accept_key_auth(*actions)
                 ActiveSupport::Deprecation.warn "ApplicationController.accept_key_auth is deprecated and will be removed in Redmine 1.4. Use accept_rss_auth (or accept_api_auth) instead."
                 accept_rss_auth(*actions)
               end
               # TODO: remove in Redmine 1.4
               def accept_key_auth_actions
                 ActiveSupport::Deprecation.warn "ApplicationController.accept_key_auth_actions is deprecated and will be removed in Redmine 1.4. Use accept_rss_auth (or accept_api_auth) instead."
                 self.class.accept_rss_auth
               end
               def self.accept_rss_auth(*actions)
                 if actions.any?
                   write_inheritable_attribute('accept_rss_auth_actions', actions)
                 else
                   read_inheritable_attribute('accept_rss_auth_actions') || []
                 end
               end
               def accept_rss_auth?(action=action_name)
                 self.class.accept_rss_auth.include?(action.to_sym)
               end
               def self.accept_api_auth(*actions)
                 if actions.any?
                   write_inheritable_attribute('accept_api_auth_actions', actions)
                 else
                   read_inheritable_attribute('accept_api_auth_actions') || []
                 end
               end
               def accept_api_auth?(action=action_name)
                 self.class.accept_api_auth.include?(action.to_sym)
               end
               # Returns the number of objects that should be displayed
               # on the paginated list
               def per_page_option
                 per_page = nil
                 if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                   per_page = params[:per_page].to_s.to_i
                   session[:per_page] = per_page
                 elsif session[:per_page]
                   per_page = session[:per_page]
                 else
                   per_page = Setting.per_page_options_array.first || 25
                 end
                 per_page
               end
               # Returns offset and limit used to retrieve objects
               # for an API response based on offset, limit and page parameters
               def api_offset_and_limit(options=params)
                 if options[:offset].present?
                   offset = options[:offset].to_i
                   if offset < 0
                     offset = 0
                   end
                 end
                 limit = options[:limit].to_i
                 if limit < 1
                   limit = 25
                 elsif limit > 100
                   limit = 100
                 end
                 if offset.nil? && options[:page].present?
                   offset = (options[:page].to_i - 1) * limit
                   offset = 0 if offset < 0
                 end
                 offset ||= 0
                 [offset, limit]
               end
               # qvalues http header parser
               # code taken from webrick
               def parse_qvalues(value)
                 tmp = []
                 if value
                   parts = value.split(/,\s*/)
                   parts.each {|part|
                     if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                       val = m[1]
                       q = (m[2] or 1).to_f
                       tmp.push([val, q])
                     end
                   }
                   tmp = tmp.sort_by{|val, q| -q}
                   tmp.collect!{|val, q| val}
                 end
                 return tmp
               rescue
                 nil
               end
               # Returns a string that can be used as filename value in Content-Disposition header
               def filename_for_content_disposition(name)
                 request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
               end
               def api_request?
                 %w(xml json).include? params[:format]
               end
               # Returns the API key present in the request
               def api_key_from_request
                 if params[:key].present?
                   params[:key]
                 elsif request.headers["X-Redmine-API-Key"].present?
                   request.headers["X-Redmine-API-Key"]
                 end
               end
               # Renders a warning flash if obj has unsaved attachments
               def render_attachment_warning_if_needed(obj)
                 flash[:warning] = l(:warning_attachments_not_saved, obj.unsaved_attachments.size) if obj.unsaved_attachments.present?
               end
               # Sets the `flash` notice or error based the number of issues that did not save
               #
               # @param [Array, Issue] issues all of the saved and unsaved Issues
               # @param [Array, Integer] unsaved_issue_ids the issue ids that were not saved
               def set_flash_from_bulk_issue_save(issues, unsaved_issue_ids)
                 if unsaved_issue_ids.empty?
                   flash[:notice] = l(:notice_successful_update) unless issues.empty?
                 else
                   flash[:error] = l(:notice_failed_to_save_issues,
                                     :count => unsaved_issue_ids.size,
                                     :total => issues.size,
                                     :ids => '#' + unsaved_issue_ids.join(', #'))
                 end
               end
               # Rescues an invalid query statement. Just in case...
               def query_statement_invalid(exception)
                 logger.error "Query::StatementInvalid: #{exception.message}" if logger
                 session.delete(:query)
                 sort_clear if respond_to?(:sort_clear)
                 render_error "An error occurred while executing the query and has been logged. Please report this error to your Redmine administrator."
               end
               # Renders API response on validation failure
               def render_validation_errors(object)
-                options = { :status => :unprocessable_entity, :layout => false }
+                @error_messages = object.errors.full_messages
-                options.merge!(case params[:format]
+                render :template => 'common/error_messages.api', :status => :unprocessable_entity, :layout => false
-                  when 'xml';  { :xml =>  object.errors }
-                  when 'json'; { :json => {'errors' => object.errors} } # ActiveResource client compliance
-                  else
-                    raise "Unknown format #{params[:format]} in #render_validation_errors"
-                  end
-                render options
               end
               # Overrides #default_template so that the api template
               # is used automatically if it exists
               def default_template(action_name = self.action_name)
                 if api_request?
                   begin
                     return self.view_paths.find_template(default_template_name(action_name), 'api')
                   rescue ::ActionView::MissingTemplate
                     # the api template was not found
                     # fallback to the default behaviour
                   end
                 end
                 super
               end
               # Overrides #pick_layout so that #render with no arguments
               # doesn't use the layout for api requests
               def pick_layout(*args)
                 api_request? ? nil : super
               end
             end

test/integration/api_test/issues_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class ApiTest::IssuesTest < ActionController::IntegrationTest
               fixtures :projects,
                 :users,
                 :roles,
                 :members,
                 :member_roles,
                 :issues,
                 :issue_statuses,
                 :versions,
                 :trackers,
                 :projects_trackers,
                 :issue_categories,
                 :enabled_modules,
                 :enumerations,
                 :attachments,
                 :workflows,
                 :custom_fields,
                 :custom_values,
                 :custom_fields_projects,
                 :custom_fields_trackers,
                 :time_entries,
                 :journals,
                 :journal_details,
                 :queries,
                 :attachments
               def setup
                 Setting.rest_api_enabled = '1'
               end
               context "/issues" do
                 # Use a private project to make sure auth is really working and not just
                 # only showing public issues.
                 should_allow_api_authentication(:get, "/projects/private-child/issues.xml")
                 should "contain metadata" do
                   get '/issues.xml'
                   assert_tag :tag => 'issues',
                     :attributes => {
                       :type => 'array',
                       :total_count => assigns(:issue_count),
                       :limit => 25,
                       :offset => 0
                     }
                 end
                 context "with offset and limit" do
                   should "use the params" do
                     get '/issues.xml?offset=2&limit=3'
                     assert_equal 3, assigns(:limit)
                     assert_equal 2, assigns(:offset)
                     assert_tag :tag => 'issues', :children => {:count => 3, :only => {:tag => 'issue'}}
                   end
                 end
                 context "with nometa param" do
                   should "not contain metadata" do
                     get '/issues.xml?nometa=1'
                     assert_tag :tag => 'issues',
                       :attributes => {
                         :type => 'array',
                         :total_count => nil,
                         :limit => nil,
                         :offset => nil
                       }
                   end
                 end
                 context "with nometa header" do
                   should "not contain metadata" do
                     get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                     assert_tag :tag => 'issues',
                       :attributes => {
                         :type => 'array',
                         :total_count => nil,
                         :limit => nil,
                         :offset => nil
                       }
                   end
                 end
                 context "with relations" do
                   should "display relations" do
                     get '/issues.xml?include=relations'
                     assert_response :success
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'relations',
                       :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '3'}},
                       :children => {:count => 1},
                       :child => {
                         :tag => 'relation',
                         :attributes => {:id => '2', :issue_id => '2', :issue_to_id => '3', :relation_type => 'relates'}
                       }
                     assert_tag 'relations',
                       :parent => {:tag => 'issue', :child => {:tag => 'id', :content => '1'}},
                       :children => {:count => 0}
                   end
                 end
                 context "with invalid query params" do
                   should "return errors" do
                     get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
                     assert_response :unprocessable_entity
                     assert_equal 'application/xml', @response.content_type
                     assert_tag 'errors', :child => {:tag => 'error', :content => "Start date can't be blank"}
                   end
                 end
                 context "with custom field filter" do
                   should "show only issues with the custom field value" do
                     get '/issues.xml', { :set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
                     expected_ids = Issue.visible.all(
                         :include => :custom_values,
                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
                     assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                        ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                     end
                   end
                 end
                 context "with custom field filter (shorthand method)" do
                   should "show only issues with the custom field value" do
                     get '/issues.xml', { :cf_1 => 'MySQL' }
                     expected_ids = Issue.visible.all(
                         :include => :custom_values,
                         :conditions => {:custom_values => {:custom_field_id => 1, :value => 'MySQL'}}).map(&:id)
                     assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                       ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                     end
                   end
                 end
               end
               context "/index.json" do
                 should_allow_api_authentication(:get, "/projects/private-child/issues.json")
               end
               context "/index.xml with filter" do
                 should "show only issues with the status_id" do
                   get '/issues.xml?status_id=5'
                   expected_ids = Issue.visible.all(:conditions => {:status_id => 5}).map(&:id)
                   assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                      ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                   end
                 end
               end
               context "/index.json with filter" do
                 should "show only issues with the status_id" do
                   get '/issues.json?status_id=5'
                   json = ActiveSupport::JSON.decode(response.body)
                   status_ids_used = json['issues'].collect {|j| j['status']['id'] }
                   assert_equal 3, status_ids_used.length
                   assert status_ids_used.all? {|id| id == 5 }
                 end
               end
               # Issue 6 is on a private project
               context "/issues/6.xml" do
                 should_allow_api_authentication(:get, "/issues/6.xml")
               end
               context "/issues/6.json" do
                 should_allow_api_authentication(:get, "/issues/6.json")
               end
               context "GET /issues/:id" do
                 context "with journals" do
                   context ".xml" do
                     should "display journals" do
                       get '/issues/1.xml?include=journals'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'journals',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'journal',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'details',
                               :attributes => { :type => 'array' },
                               :child => {
                                 :tag => 'detail',
                                 :attributes => { :name => 'status_id' },
                                 :child => {
                                   :tag => 'old_value',
                                   :content => '1',
                                   :sibling => {
                                     :tag => 'new_value',
                                     :content => '2'
                                   }
                                 }
                               }
                             }
                           }
                         }
                     end
                   end
                 end
                 context "with custom fields" do
                   context ".xml" do
                     should "display custom fields" do
                       get '/issues/3.xml'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'custom_fields',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'custom_field',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'value',
                               :content => 'MySQL'
                             }
                           }
                         }
                       assert_nothing_raised do
                         Hash.from_xml(response.body).to_xml
                       end
                     end
                   end
                 end
                 context "with multi custom fields" do
                   setup do
                     field = CustomField.find(1)
                     field.update_attribute :multiple, true
                     issue = Issue.find(3)
                     issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                     issue.save!
                   end
                   context ".xml" do
                     should "display custom fields" do
                       get '/issues/3.xml'
                       assert_response :success
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'custom_fields',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'custom_field',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'value',
                               :attributes => { :type => 'array' },
                               :children => { :count => 2 }
                             }
                           }
                         }
                       xml = Hash.from_xml(response.body)
                       custom_fields = xml['issue']['custom_fields']
                       assert_kind_of Array, custom_fields
                       field = custom_fields.detect {|f| f['id'] == '1'}
                       assert_kind_of Hash, field
                       assert_equal ['MySQL', 'Oracle'], field['value'].sort
                     end
                   end
                   context ".json" do
                     should "display custom fields" do
                       get '/issues/3.json'
                       assert_response :success
                       json = ActiveSupport::JSON.decode(response.body)
                       custom_fields = json['issue']['custom_fields']
                       assert_kind_of Array, custom_fields
                       field = custom_fields.detect {|f| f['id'] == 1}
                       assert_kind_of Hash, field
                       assert_equal ['MySQL', 'Oracle'], field['value'].sort
                     end
                   end
                 end
                 context "with empty value for multi custom field" do
                   setup do
                     field = CustomField.find(1)
                     field.update_attribute :multiple, true
                     issue = Issue.find(3)
                     issue.custom_field_values = {1 => ['']}
                     issue.save!
                   end
                   context ".xml" do
                     should "display custom fields" do
                       get '/issues/3.xml'
                       assert_response :success
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'custom_fields',
                           :attributes => { :type => 'array' },
                           :child => {
                             :tag => 'custom_field',
                             :attributes => { :id => '1'},
                             :child => {
                               :tag => 'value',
                               :attributes => { :type => 'array' },
                               :children => { :count => 0 }
                             }
                           }
                         }
                       xml = Hash.from_xml(response.body)
                       custom_fields = xml['issue']['custom_fields']
                       assert_kind_of Array, custom_fields
                       field = custom_fields.detect {|f| f['id'] == '1'}
                       assert_kind_of Hash, field
                       assert_equal [], field['value']
                     end
                   end
                   context ".json" do
                     should "display custom fields" do
                       get '/issues/3.json'
                       assert_response :success
                       json = ActiveSupport::JSON.decode(response.body)
                       custom_fields = json['issue']['custom_fields']
                       assert_kind_of Array, custom_fields
                       field = custom_fields.detect {|f| f['id'] == 1}
                       assert_kind_of Hash, field
                       assert_equal [], field['value'].sort
                     end
                   end
                 end
                 context "with attachments" do
                   context ".xml" do
                     should "display attachments" do
                       get '/issues/3.xml?include=attachments'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'attachments',
                           :children => {:count => 5},
                           :child => {
                             :tag => 'attachment',
                             :child => {
                               :tag => 'filename',
                               :content => 'source.rb',
                               :sibling => {
                                 :tag => 'content_url',
                                 :content => 'http://www.example.com/attachments/download/4/source.rb'
                               }
                             }
                           }
                         }
                     end
                   end
                 end
                 context "with subtasks" do
                   setup do
                     @c1 = Issue.create!(:status_id => 1, :subject => "child c1", :tracker_id => 1, :project_id => 1, :author_id => 1, :parent_issue_id => 1)
                     @c2 = Issue.create!(:status_id => 1, :subject => "child c2", :tracker_id => 1, :project_id => 1, :author_id => 1, :parent_issue_id => 1)
                     @c3 = Issue.create!(:status_id => 1, :subject => "child c3", :tracker_id => 1, :project_id => 1, :author_id => 1, :parent_issue_id => @c1.id)
                   end
                   context ".xml" do
                     should "display children" do
                       get '/issues/1.xml?include=children'
                       assert_tag :tag => 'issue',
                         :child => {
                           :tag => 'children',
                           :children => {:count => 2},
                           :child => {
                             :tag => 'issue',
                             :attributes => {:id => @c1.id.to_s},
                             :child => {
                               :tag => 'subject',
                               :content => 'child c1',
                               :sibling => {
                                 :tag => 'children',
                                 :children => {:count => 1},
                                 :child => {
                                   :tag => 'issue',
                                   :attributes => {:id => @c3.id.to_s}
                                 }
                               }
                             }
                           }
                         }
                     end
                     context ".json" do
                       should "display children" do
                         get '/issues/1.json?include=children'
                         json = ActiveSupport::JSON.decode(response.body)
                         assert_equal([
                           {
                             'id' => @c1.id, 'subject' => 'child c1', 'tracker' => {'id' => 1, 'name' => 'Bug'},
                             'children' => [{ 'id' => @c3.id, 'subject' => 'child c3', 'tracker' => {'id' => 1, 'name' => 'Bug'} }]
                           },
                           { 'id' => @c2.id, 'subject' => 'child c2', 'tracker' => {'id' => 1, 'name' => 'Bug'} }
                           ],
                           json['issue']['children'])
                       end
                     end
                   end
                 end
               end
               context "POST /issues.xml" do
                 should_allow_api_authentication(:post,
                                                 '/issues.xml',
                                                 {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
                                                 {:success_code => :created})
                 should "create an issue with the attributes" do
                   assert_difference('Issue.count') do
                     post '/issues.xml', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, credentials('jsmith')
                   end
                   issue = Issue.first(:order => 'id DESC')
                   assert_equal 1, issue.project_id
                   assert_equal 2, issue.tracker_id
                   assert_equal 3, issue.status_id
                   assert_equal 'API test', issue.subject
                   assert_response :created
                   assert_equal 'application/xml', @response.content_type
                   assert_tag 'issue', :child => {:tag => 'id', :content => issue.id.to_s}
                 end
               end
               context "POST /issues.xml with failure" do
                 should "have an errors tag" do
                   assert_no_difference('Issue.count') do
                     post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                   end
                   assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
                 end
               end
               context "POST /issues.json" do
                 should_allow_api_authentication(:post,
                                                 '/issues.json',
                                                 {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
                                                 {:success_code => :created})
                 should "create an issue with the attributes" do
                   assert_difference('Issue.count') do
                     post '/issues.json', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, credentials('jsmith')
                   end
                   issue = Issue.first(:order => 'id DESC')
                   assert_equal 1, issue.project_id
                   assert_equal 2, issue.tracker_id
                   assert_equal 3, issue.status_id
                   assert_equal 'API test', issue.subject
                 end
               end
               context "POST /issues.json with failure" do
                 should "have an errors element" do
                   assert_no_difference('Issue.count') do
                     post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
                   end
                   json = ActiveSupport::JSON.decode(response.body)
-                  assert json['errors'].include?(['subject', "can't be blank"])
+                  assert json['errors'].include?("Subject can't be blank")
                 end
               end
               # Issue 6 is on a private project
               context "PUT /issues/6.xml" do
                 setup do
                   @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
                 end
                 should_allow_api_authentication(:put,
                                                 '/issues/6.xml',
                                                 {:issue => {:subject => 'API update', :notes => 'A new note'}},
                                                 {:success_code => :ok})
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
                     put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "create a new journal" do
                   assert_difference('Journal.count') do
                     put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "add the note to the journal" do
                   put '/issues/6.xml', @parameters, credentials('jsmith')
                   journal = Journal.last
                   assert_equal "A new note", journal.notes
                 end
                 should "update the issue" do
                   put '/issues/6.xml', @parameters, credentials('jsmith')
                   issue = Issue.find(6)
                   assert_equal "API update", issue.subject
                 end
               end
               context "PUT /issues/3.xml with custom fields" do
                 setup do
                   @parameters = {:issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' }, {'id' => '2', 'value' => '150'}]}}
                 end
                 should "update custom fields" do
                   assert_no_difference('Issue.count') do
                     put '/issues/3.xml', @parameters, credentials('jsmith')
                   end
                   issue = Issue.find(3)
                   assert_equal '150', issue.custom_value_for(2).value
                   assert_equal 'PostgreSQL', issue.custom_value_for(1).value
                 end
               end
               context "PUT /issues/3.xml with multi custom fields" do
                 setup do
                   field = CustomField.find(1)
                   field.update_attribute :multiple, true
                   @parameters = {:issue => {:custom_fields => [{'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] }, {'id' => '2', 'value' => '150'}]}}
                 end
                 should "update custom fields" do
                   assert_no_difference('Issue.count') do
                     put '/issues/3.xml', @parameters, credentials('jsmith')
                   end
                   issue = Issue.find(3)
                   assert_equal '150', issue.custom_value_for(2).value
                   assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
                 end
               end
               context "PUT /issues/3.xml with project change" do
                 setup do
                   @parameters = {:issue => {:project_id => 2, :subject => 'Project changed'}}
                 end
                 should "update project" do
                   assert_no_difference('Issue.count') do
                     put '/issues/3.xml', @parameters, credentials('jsmith')
                   end
                   issue = Issue.find(3)
                   assert_equal 2, issue.project_id
                   assert_equal 'Project changed', issue.subject
                 end
               end
               context "PUT /issues/6.xml with failed update" do
                 setup do
                   @parameters = {:issue => {:subject => ''}}
                 end
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
                     put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "not create a new journal" do
                   assert_no_difference('Journal.count') do
                     put '/issues/6.xml', @parameters, credentials('jsmith')
                   end
                 end
                 should "have an errors tag" do
                   put '/issues/6.xml', @parameters, credentials('jsmith')
                   assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
                 end
               end
               context "PUT /issues/6.json" do
                 setup do
                   @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
                 end
                 should_allow_api_authentication(:put,
                                                 '/issues/6.json',
                                                 {:issue => {:subject => 'API update', :notes => 'A new note'}},
                                                 {:success_code => :ok})
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
                     put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "create a new journal" do
                   assert_difference('Journal.count') do
                     put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "add the note to the journal" do
                   put '/issues/6.json', @parameters, credentials('jsmith')
                   journal = Journal.last
                   assert_equal "A new note", journal.notes
                 end
                 should "update the issue" do
                   put '/issues/6.json', @parameters, credentials('jsmith')
                   issue = Issue.find(6)
                   assert_equal "API update", issue.subject
                 end
               end
               context "PUT /issues/6.json with failed update" do
                 setup do
                   @parameters = {:issue => {:subject => ''}}
                 end
                 should "not create a new issue" do
                   assert_no_difference('Issue.count') do
                     put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "not create a new journal" do
                   assert_no_difference('Journal.count') do
                     put '/issues/6.json', @parameters, credentials('jsmith')
                   end
                 end
                 should "have an errors attribute" do
                   put '/issues/6.json', @parameters, credentials('jsmith')
                   json = ActiveSupport::JSON.decode(response.body)
-                  assert json['errors'].include?(['subject', "can't be blank"])
+                  assert json['errors'].include?("Subject can't be blank")
                 end
               end
               context "DELETE /issues/1.xml" do
                 should_allow_api_authentication(:delete,
                                                 '/issues/6.xml',
                                                 {},
                                                 {:success_code => :ok})
                 should "delete the issue" do
                   assert_difference('Issue.count',-1) do
                     delete '/issues/6.xml', {}, credentials('jsmith')
                   end
                   assert_nil Issue.find_by_id(6)
                 end
               end
               context "DELETE /issues/1.json" do
                 should_allow_api_authentication(:delete,
                                                 '/issues/6.json',
                                                 {},
                                                 {:success_code => :ok})
                 should "delete the issue" do
                   assert_difference('Issue.count',-1) do
                     delete '/issues/6.json', {}, credentials('jsmith')
                   end
                   assert_nil Issue.find_by_id(6)
                 end
               end
               def test_create_issue_with_uploaded_file
                 set_tmp_attachments_directory
                 # upload the file
                 assert_difference 'Attachment.count' do
                   post '/uploads.xml', 'test_create_with_upload', {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                   assert_response :created
                 end
                 xml = Hash.from_xml(response.body)
                 token = xml['upload']['token']
                 attachment = Attachment.first(:order => 'id DESC')
                 # create the issue with the upload's token
                 assert_difference 'Issue.count' do
                   post '/issues.xml',
                     {:issue => {:project_id => 1, :subject => 'Uploaded file', :uploads => [{:token => token, :filename => 'test.txt', :content_type => 'text/plain'}]}},
                     credentials('jsmith')
                   assert_response :created
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal 1, issue.attachments.count
                 assert_equal attachment, issue.attachments.first
                 attachment.reload
                 assert_equal 'test.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test_create_with_upload'.size, attachment.filesize
                 assert_equal 2, attachment.author_id
                 # get the issue with its attachments
                 get "/issues/#{issue.id}.xml", :include => 'attachments'
                 assert_response :success
                 xml = Hash.from_xml(response.body)
                 attachments = xml['issue']['attachments']
                 assert_kind_of Array, attachments
                 assert_equal 1, attachments.size
                 url = attachments.first['content_url']
                 assert_not_nil url
                 # download the attachment
                 get url
                 assert_response :success
               end
               def test_update_issue_with_uploaded_file
                 set_tmp_attachments_directory
                 # upload the file
                 assert_difference 'Attachment.count' do
                   post '/uploads.xml', 'test_upload_with_upload', {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials('jsmith'))
                   assert_response :created
                 end
                 xml = Hash.from_xml(response.body)
                 token = xml['upload']['token']
                 attachment = Attachment.first(:order => 'id DESC')
                 # update the issue with the upload's token
                 assert_difference 'Journal.count' do
                   put '/issues/1.xml',
                     {:issue => {:notes => 'Attachment added', :uploads => [{:token => token, :filename => 'test.txt', :content_type => 'text/plain'}]}},
                     credentials('jsmith')
                   assert_response :ok
                 end
                 issue = Issue.find(1)
                 assert_include attachment, issue.attachments
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages