jro_apps/redmine Commit - r3573:9b595c689d06

Refactor: Move the rest of the routing tests to RoutingTest....

Eric Davis -

r3573:9b595c689d06

parent child

Context file:

r3573:9b595c689d06

Collapse all files

test/functional/attachments_controller_test.rb 0 -15

             # redMine - project management software
             # Copyright (C) 2006-2008  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.dirname(__FILE__) + '/../test_helper'
             require 'attachments_controller'
             # Re-raise errors caught by the controller.
             class AttachmentsController; def rescue_action(e) raise e end; end
             class AttachmentsControllerTest < ActionController::TestCase
               fixtures :users, :projects, :roles, :members, :member_roles, :enabled_modules, :issues, :trackers, :attachments,
                        :versions, :wiki_pages, :wikis, :documents
               def setup
                 @controller = AttachmentsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 Attachment.storage_path = "#{RAILS_ROOT}/test/fixtures/files"
                 User.current = nil
               end
-              def test_routing
-                assert_routing('/attachments/1', :controller => 'attachments', :action => 'show', :id => '1')
-                assert_routing('/attachments/1/filename.ext', :controller => 'attachments', :action => 'show', :id => '1', :filename => 'filename.ext')
-                assert_routing('/attachments/download/1', :controller => 'attachments', :action => 'download', :id => '1')
-                assert_routing('/attachments/download/1/filename.ext', :controller => 'attachments', :action => 'download', :id => '1', :filename => 'filename.ext')
-              end
-              def test_recognizes
-                assert_recognizes({:controller => 'attachments', :action => 'show', :id => '1'}, '/attachments/1')
-                assert_recognizes({:controller => 'attachments', :action => 'show', :id => '1'}, '/attachments/show/1')
-                assert_recognizes({:controller => 'attachments', :action => 'show', :id => '1', :filename => 'filename.ext'}, '/attachments/1/filename.ext')
-                assert_recognizes({:controller => 'attachments', :action => 'download', :id => '1'}, '/attachments/download/1')
-                assert_recognizes({:controller => 'attachments', :action => 'download', :id => '1', :filename => 'filename.ext'},'/attachments/download/1/filename.ext')
-              end
               def test_show_diff
                 get :show, :id => 5
                 assert_response :success
                 assert_template 'diff'
                 assert_equal 'text/html', @response.content_type
               end
               def test_show_text_file
                 get :show, :id => 4
                 assert_response :success
                 assert_template 'file'
                 assert_equal 'text/html', @response.content_type
               end
               def test_show_text_file_should_send_if_too_big
                 Setting.file_max_size_displayed = 512
                 Attachment.find(4).update_attribute :filesize, 754.kilobyte
                 get :show, :id => 4
                 assert_response :success
                 assert_equal 'application/x-ruby', @response.content_type
               end
               def test_show_other
                 get :show, :id => 6
                 assert_response :success
                 assert_equal 'application/octet-stream', @response.content_type
               end
               def test_download_text_file
                 get :download, :id => 4
                 assert_response :success
                 assert_equal 'application/x-ruby', @response.content_type
               end
               def test_download_should_assign_content_type_if_blank
                 Attachment.find(4).update_attribute(:content_type, '')
                 get :download, :id => 4
                 assert_response :success
                 assert_equal 'text/x-ruby', @response.content_type
               end
               def test_download_missing_file
                 get :download, :id => 2
                 assert_response 404
               end
               def test_anonymous_on_private_private
                 get :download, :id => 7
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fattachments%2Fdownload%2F7'
               end
               def test_destroy_issue_attachment
                 issue = Issue.find(3)
                 @request.session[:user_id] = 2
                 assert_difference 'issue.attachments.count', -1 do
                   post :destroy, :id => 1
                 end
                 # no referrer
                 assert_redirected_to 'projects/ecookbook'
                 assert_nil Attachment.find_by_id(1)
                 j = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal 'attachment', j.details.first.property
                 assert_equal '1', j.details.first.prop_key
                 assert_equal 'error281.txt', j.details.first.old_value
               end
               def test_destroy_wiki_page_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   post :destroy, :id => 3
                   assert_response 302
                 end
               end
               def test_destroy_project_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   post :destroy, :id => 8
                   assert_response 302
                 end
               end
               def test_destroy_version_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   post :destroy, :id => 9
                   assert_response 302
                 end
               end
               def test_destroy_without_permission
                 post :destroy, :id => 3
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fattachments%2Fdestroy%2F3'
                 assert Attachment.find_by_id(3)
               end
             end

test/functional/boards_controller_test.rb 0 -47

             # Redmine - project management software
             # Copyright (C) 2006-2009  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.dirname(__FILE__) + '/../test_helper'
             require 'boards_controller'
             # Re-raise errors caught by the controller.
             class BoardsController; def rescue_action(e) raise e end; end
             class BoardsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles, :boards, :messages, :enabled_modules
               def setup
                 @controller = BoardsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/boards'},
-                  :controller => 'boards', :action => 'index', :project_id => 'world_domination'
-              end
               def test_index
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:boards)
                 assert_not_nil assigns(:project)
               end
               def test_index_not_found
                 get :index, :project_id => 97
                 assert_response 404
               end
               def test_index_should_show_messages_if_only_one_board
                 Project.find(1).boards.slice(1..-1).each(&:destroy)
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:topics)
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/boards/new'},
-                  :controller => 'boards', :action => 'new', :project_id => 'world_domination'
-                assert_recognizes(
-                  {:controller => 'boards', :action => 'new', :project_id => 'world_domination'},
-                  {:method => :post, :path => '/projects/world_domination/boards'}
-              end
               def test_post_new
                 @request.session[:user_id] = 2
                 assert_difference 'Board.count' do
                   post :new, :project_id => 1, :board => { :name => 'Testing', :description => 'Testing board creation'}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/boards'
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/boards/44'},
-                  :controller => 'boards', :action => 'show', :id => '44', :project_id => 'world_domination'
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/boards/44.atom'},
-                  :controller => 'boards', :action => 'show', :id => '44', :project_id => 'world_domination', :format => 'atom'
-              end
               def test_show
                 get :show, :project_id => 1, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:board)
                 assert_not_nil assigns(:project)
                 assert_not_nil assigns(:topics)
               end
               def test_show_atom
                 get :show, :project_id => 1, :id => 1, :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed.atom'
                 assert_not_nil assigns(:board)
                 assert_not_nil assigns(:project)
                 assert_not_nil assigns(:messages)
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/boards/44/edit'},
-                  :controller => 'boards', :action => 'edit', :id => '44', :project_id => 'world_domination'
-                assert_recognizes(#TODO: use PUT method to board_path, modify form accordingly
-                  {:controller => 'boards', :action => 'edit', :id => '44', :project_id => 'world_domination'},
-                  {:method => :post, :path => '/projects/world_domination/boards/44/edit'}
-              end
               def test_post_edit
                 @request.session[:user_id] = 2
                 assert_no_difference 'Board.count' do
                   post :edit, :project_id => 1, :id => 2, :board => { :name => 'Testing', :description => 'Testing board update'}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/boards'
                 assert_equal 'Testing', Board.find(2).name
               end
-              def test_destroy_routing
-                assert_routing(#TODO: use DELETE method to board_path, modify form accoringly
-                  {:method => :post, :path => '/projects/world_domination/boards/44/destroy'},
-                  :controller => 'boards', :action => 'destroy', :id => '44', :project_id => 'world_domination'
-              end
               def test_post_destroy
                 @request.session[:user_id] = 2
                 assert_difference 'Board.count', -1 do
                   post :destroy, :project_id => 1, :id => 2
                 end
                 assert_redirected_to '/projects/ecookbook/settings/boards'
                 assert_nil Board.find_by_id(2)
               end
             end

test/functional/documents_controller_test.rb 0 -43

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'documents_controller'
             # Re-raise errors caught by the controller.
             class DocumentsController; def rescue_action(e) raise e end; end
             class DocumentsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules, :documents, :enumerations
               def setup
                 @controller = DocumentsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/documents'},
-                  :controller => 'documents', :action => 'index', :project_id => '567'
-              end
               def test_index
                 # Sets a default category
                 e = Enumeration.find_by_name('Technical documentation')
                 e.update_attributes(:is_default => true)
                 get :index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:grouped)
                 # Default category selected in the new document form
                 assert_tag :select, :attributes => {:name => 'document[category_id]'},
                                     :child => {:tag => 'option', :attributes => {:selected => 'selected'},
                                                                  :content => 'Technical documentation'}
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/documents/new'},
-                  :controller => 'documents', :action => 'new', :project_id => '567'
-                assert_recognizes(
-                  {:controller => 'documents', :action => 'new', :project_id => '567'},
-                  {:method => :post, :path => '/projects/567/documents'}
-              end
               def test_new_with_one_attachment
                 ActionMailer::Base.deliveries.clear
                 Setting.notified_events << 'document_added'
                 @request.session[:user_id] = 2
                 set_tmp_attachments_directory
                 post :new, :project_id => 'ecookbook',
                            :document => { :title => 'DocumentsControllerTest#test_post_new',
                                           :description => 'This is a new document',
                                           :category_id => 2},
                            :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 assert_redirected_to 'projects/ecookbook/documents'
                 document = Document.find_by_title('DocumentsControllerTest#test_post_new')
                 assert_not_nil document
                 assert_equal Enumeration.find(2), document.category
                 assert_equal 1, document.attachments.size
                 assert_equal 'testfile.txt', document.attachments.first.filename
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/documents/22/edit'},
-                  :controller => 'documents', :action => 'edit', :id => '22'
-                assert_recognizes(#TODO: should be using PUT on document URI
-                  {:controller => 'documents', :action => 'edit', :id => '567'},
-                  {:method => :post, :path => '/documents/567/edit'}
-              end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/documents/22'},
-                  :controller => 'documents', :action => 'show', :id => '22'
-              end
-              def test_destroy_routing
-                assert_recognizes(#TODO: should be using DELETE on document URI
-                  {:controller => 'documents', :action => 'destroy', :id => '567'},
-                  {:method => :post, :path => '/documents/567/destroy'}
-              end
               def test_destroy
                 @request.session[:user_id] = 2
                 post :destroy, :id => 1
                 assert_redirected_to 'projects/ecookbook/documents'
                 assert_nil Document.find_by_id(1)
               end
             end

test/functional/issue_categories_controller_test.rb 0 -11

             # Redmine - project management software
             # Copyright (C) 2006-2009  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.dirname(__FILE__) + '/../test_helper'
             require 'issue_categories_controller'
             # Re-raise errors caught by the controller.
             class IssueCategoriesController; def rescue_action(e) raise e end; end
             class IssueCategoriesControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles, :enabled_modules, :issue_categories
               def setup
                 @controller = IssueCategoriesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
                 @request.session[:user_id] = 2
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :get, :path => 'projects/test/issue_categories/new'},
-                  :controller => 'issue_categories', :action => 'new', :project_id => 'test'
-                assert_routing(
-                  {:method => :post, :path => 'projects/test/issue_categories/new'},
-                  :controller => 'issue_categories', :action => 'new', :project_id => 'test'
-              end
               def test_get_new
                 @request.session[:user_id] = 2 # manager
                 get :new, :project_id => '1'
                 assert_response :success
                 assert_template 'new'
               end
               def test_post_new
                 @request.session[:user_id] = 2 # manager
                 assert_difference 'IssueCategory.count' do
                   post :new, :project_id => '1', :category => {:name => 'New category'}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/categories'
                 category = IssueCategory.find_by_name('New category')
                 assert_not_nil category
                 assert_equal 1, category.project_id
               end
               def test_post_edit
                 assert_no_difference 'IssueCategory.count' do
                   post :edit, :id => 2, :category => { :name => 'Testing' }
                 end
                 assert_redirected_to '/projects/ecookbook/settings/categories'
                 assert_equal 'Testing', IssueCategory.find(2).name
               end
               def test_edit_not_found
                 post :edit, :id => 97, :category => { :name => 'Testing' }
                 assert_response 404
               end
               def test_destroy_category_not_in_use
                 post :destroy, :id => 2
                 assert_redirected_to '/projects/ecookbook/settings/categories'
                 assert_nil IssueCategory.find_by_id(2)
               end
               def test_destroy_category_in_use
                 post :destroy, :id => 1
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil IssueCategory.find_by_id(1)
               end
               def test_destroy_category_in_use_with_reassignment
                 issue = Issue.find(:first, :conditions => {:category_id => 1})
                 post :destroy, :id => 1, :todo => 'reassign', :reassign_to_id => 2
                 assert_redirected_to '/projects/ecookbook/settings/categories'
                 assert_nil IssueCategory.find_by_id(1)
                 # check that the issue was reassign
                 assert_equal 2, issue.reload.category_id
               end
               def test_destroy_category_in_use_without_reassignment
                 issue = Issue.find(:first, :conditions => {:category_id => 1})
                 post :destroy, :id => 1, :todo => 'nullify'
                 assert_redirected_to '/projects/ecookbook/settings/categories'
                 assert_nil IssueCategory.find_by_id(1)
                 # check that the issue category was nullified
                 assert_nil issue.reload.category_id
               end
             end

test/functional/issue_relations_controller_test.rb 0 -14

             require File.dirname(__FILE__) + '/../test_helper'
             require 'issue_relations_controller'
             # Re-raise errors caught by the controller.
             class IssueRelationsController; def rescue_action(e) raise e end; end
             class IssueRelationsControllerTest < ActionController::TestCase
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :issue_relations,
                        :enabled_modules,
                        :enumerations,
                        :trackers
               def setup
                 @controller = IssueRelationsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :post, :path => '/issues/1/relations'},
-                  {:controller => 'issue_relations', :action => 'new', :issue_id => '1'}
-              end
               def test_new
                 assert_difference 'IssueRelation.count' do
                   @request.session[:user_id] = 3
                   post :new, :issue_id => 1,
                              :relation => {:issue_to_id => '2', :relation_type => 'relates', :delay => ''}
                 end
               end
               def test_new_should_accept_id_with_hash
                 assert_difference 'IssueRelation.count' do
                   @request.session[:user_id] = 3
                   post :new, :issue_id => 1,
                              :relation => {:issue_to_id => '#2', :relation_type => 'relates', :delay => ''}
                 end
               end
               def test_new_should_not_break_with_non_numerical_id
                 assert_no_difference 'IssueRelation.count' do
                   assert_nothing_raised do
                     @request.session[:user_id] = 3
                     post :new, :issue_id => 1,
                                :relation => {:issue_to_id => 'foo', :relation_type => 'relates', :delay => ''}
                   end
                 end
               end
               def test_should_create_relations_with_visible_issues_only
                 Setting.cross_project_issue_relations = '1'
                 assert_nil Issue.visible(User.find(3)).find_by_id(4)
                 assert_no_difference 'IssueRelation.count' do
                   @request.session[:user_id] = 3
                   post :new, :issue_id => 1,
                              :relation => {:issue_to_id => '4', :relation_type => 'relates', :delay => ''}
                 end
               end
-              def test_destroy_routing
-                assert_recognizes( #TODO: use DELETE on issue URI
-                  {:controller => 'issue_relations', :action => 'destroy', :issue_id => '1', :id => '23'},
-                  {:method => :post, :path => '/issues/1/relations/23/destroy'}
-              end
               def test_destroy
                 assert_difference 'IssueRelation.count', -1 do
                   @request.session[:user_id] = 3
                   post :destroy, :id => '2', :issue_id => '3'
                 end
               end
             end

test/functional/members_controller_test.rb 0 -7

             # Redmine - project management software
             # Copyright (C) 2006-2009  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.dirname(__FILE__) + '/../test_helper'
             require 'members_controller'
             # Re-raise errors caught by the controller.
             class MembersController; def rescue_action(e) raise e end; end
             class MembersControllerTest < ActionController::TestCase
               fixtures :projects, :members, :member_roles, :roles, :users
               def setup
                 @controller = MembersController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
                 @request.session[:user_id] = 2
               end
-              def test_members_routing
-                assert_routing(
-                  {:method => :post, :path => 'projects/5234/members/new'},
-                  :controller => 'members', :action => 'new', :id => '5234'
-              end
               def test_create
                 assert_difference 'Member.count' do
                   post :new, :id => 1, :member => {:role_ids => [1], :user_id => 7}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/members'
                 assert User.find(7).member_of?(Project.find(1))
               end
               def test_create_multiple
                 assert_difference 'Member.count', 3 do
                   post :new, :id => 1, :member => {:role_ids => [1], :user_ids => [7, 8, 9]}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/members'
                 assert User.find(7).member_of?(Project.find(1))
               end
               def test_edit
                 assert_no_difference 'Member.count' do
                   post :edit, :id => 2, :member => {:role_ids => [1], :user_id => 3}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/members'
               end
               def test_destroy
                 assert_difference 'Member.count', -1 do
                   post :destroy, :id => 2
                 end
                 assert_redirected_to '/projects/ecookbook/settings/members'
                 assert !User.find(3).member_of?(Project.find(1))
               end
               def test_autocomplete_for_member
                 get :autocomplete_for_member, :id => 1, :q => 'mis'
                 assert_response :success
                 assert_template 'autocomplete_for_member'
                 assert_tag :label, :content => /User Misc/,
                                    :child => { :tag => 'input', :attributes => { :name => 'member[user_ids][]', :value => '8' } }
               end
             end

test/functional/messages_controller_test.rb 0 -43

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'messages_controller'
             # Re-raise errors caught by the controller.
             class MessagesController; def rescue_action(e) raise e end; end
             class MessagesControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles, :boards, :messages, :enabled_modules
               def setup
                 @controller = MessagesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/boards/22/topics/2'},
-                  :controller => 'messages', :action => 'show', :id => '2', :board_id => '22'
-              end
               def test_show
                 get :show, :board_id => 1, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:board)
                 assert_not_nil assigns(:project)
                 assert_not_nil assigns(:topic)
               end
               def test_show_with_pagination
                 message = Message.find(1)
                 assert_difference 'Message.count', 30 do
 .times do
                     message.children << Message.new(:subject => 'Reply', :content => 'Reply body', :author_id => 2, :board_id => 1)
                   end
                 end
                 get :show, :board_id => 1, :id => 1, :r => message.children.last(:order => 'id').id
                 assert_response :success
                 assert_template 'show'
                 replies = assigns(:replies)
                 assert_not_nil replies
                 assert !replies.include?(message.children.first(:order => 'id'))
                 assert replies.include?(message.children.last(:order => 'id'))
               end
               def test_show_with_reply_permission
                 @request.session[:user_id] = 2
                 get :show, :board_id => 1, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_tag :div, :attributes => { :id => 'reply' },
                                  :descendant => { :tag => 'textarea', :attributes => { :id => 'message_content' } }
               end
               def test_show_message_not_found
                 get :show, :board_id => 1, :id => 99999
                 assert_response 404
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :get, :path => '/boards/lala/topics/new'},
-                  :controller => 'messages', :action => 'new', :board_id => 'lala'
-                assert_recognizes(#TODO: POST to collection, need to adjust form accordingly
-                  {:controller => 'messages', :action => 'new', :board_id => 'lala'},
-                  {:method => :post, :path => '/boards/lala/topics/new'}
-              end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :board_id => 1
                 assert_response :success
                 assert_template 'new'
               end
               def test_post_new
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 Setting.notified_events = ['message_posted']
                 post :new, :board_id => 1,
                            :message => { :subject => 'Test created message',
                                          :content => 'Message body'}
                 message = Message.find_by_subject('Test created message')
                 assert_not_nil message
                 assert_redirected_to "boards/1/topics/#{message.to_param}"
                 assert_equal 'Message body', message.content
                 assert_equal 2, message.author_id
                 assert_equal 1, message.board_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert_equal "[#{message.board.project.name} - #{message.board.name} - msg#{message.root.id}] Test created message", mail.subject
                 assert mail.body.include?('Message body')
                 # author
                 assert mail.bcc.include?('jsmith@somenet.foo')
                 # project member
                 assert mail.bcc.include?('dlopper@somenet.foo')
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/boards/lala/topics/22/edit'},
-                  :controller => 'messages', :action => 'edit', :board_id => 'lala', :id => '22'
-                assert_recognizes( #TODO: use PUT to topic_path, modify form accordingly
-                  {:controller => 'messages', :action => 'edit', :board_id => 'lala', :id => '22'},
-                  {:method => :post, :path => '/boards/lala/topics/22/edit'}
-              end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :board_id => 1, :id => 1
                 assert_response :success
                 assert_template 'edit'
               end
               def test_post_edit
                 @request.session[:user_id] = 2
                 post :edit, :board_id => 1, :id => 1,
                             :message => { :subject => 'New subject',
                                           :content => 'New body'}
                 assert_redirected_to 'boards/1/topics/1'
                 message = Message.find(1)
                 assert_equal 'New subject', message.subject
                 assert_equal 'New body', message.content
               end
-              def test_reply_routing
-                assert_recognizes(
-                  {:controller => 'messages', :action => 'reply', :board_id => '22', :id => '555'},
-                  {:method => :post, :path => '/boards/22/topics/555/replies'}
-              end
               def test_reply
                 @request.session[:user_id] = 2
                 post :reply, :board_id => 1, :id => 1, :reply => { :content => 'This is a test reply', :subject => 'Test reply' }
                 reply = Message.find(:first, :order => 'id DESC')
                 assert_redirected_to "boards/1/topics/1?r=#{reply.id}"
                 assert Message.find_by_subject('Test reply')
               end
-              def test_destroy_routing
-                assert_recognizes(#TODO: use DELETE to topic_path, adjust form accordingly
-                  {:controller => 'messages', :action => 'destroy', :board_id => '22', :id => '555'},
-                  {:method => :post, :path => '/boards/22/topics/555/destroy'}
-              end
               def test_destroy_topic
                 @request.session[:user_id] = 2
                 post :destroy, :board_id => 1, :id => 1
                 assert_redirected_to 'projects/ecookbook/boards/1'
                 assert_nil Message.find_by_id(1)
               end
               def test_quote
                 @request.session[:user_id] = 2
                 xhr :get, :quote, :board_id => 1, :id => 3
                 assert_response :success
                 assert_select_rjs :show, 'reply'
               end
             end

test/functional/news_controller_test.rb 0 -64

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'news_controller'
             # Re-raise errors caught by the controller.
             class NewsController; def rescue_action(e) raise e end; end
             class NewsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules, :news, :comments
               def setup
                 @controller = NewsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/news'},
-                  :controller => 'news', :action => 'index'
-              end
-              def test_index_routing_formatted
-                assert_routing(
-                  {:method => :get, :path => '/news.atom'},
-                  :controller => 'news', :action => 'index', :format => 'atom'
-              end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:newss)
                 assert_nil assigns(:project)
               end
-              def test_index_with_project_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/news'},
-                  :controller => 'news', :action => 'index', :project_id => '567'
-              end
-              def test_index_with_project_routing_formatted
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/news.atom'},
-                  :controller => 'news', :action => 'index', :project_id => '567', :format => 'atom'
-              end
               def test_index_with_project
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:newss)
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/news/2'},
-                  :controller => 'news', :action => 'show', :id => '2'
-              end
               def test_show
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'h2', :content => /eCookbook first release/
               end
               def test_show_not_found
                 get :show, :id => 999
                 assert_response 404
               end
-              def test_new_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/news/new'},
-                  :controller => 'news', :action => 'new', :project_id => '567'
-                assert_recognizes(
-                  {:controller => 'news', :action => 'new', :project_id => '567'},
-                  {:method => :post, :path => '/projects/567/news'}
-              end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
               end
               def test_post_new
                 ActionMailer::Base.deliveries.clear
                 Setting.notified_events << 'news_added'
                 @request.session[:user_id] = 2
                 post :new, :project_id => 1, :news => { :title => 'NewsControllerTest',
                                                         :description => 'This is the description',
                                                         :summary => '' }
                 assert_redirected_to 'projects/ecookbook/news'
                 news = News.find_by_title('NewsControllerTest')
                 assert_not_nil news
                 assert_equal 'This is the description', news.description
                 assert_equal User.find(2), news.author
                 assert_equal Project.find(1), news.project
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/news/234'},
-                  :controller => 'news', :action => 'show', :id => '234'
-                assert_recognizes(#TODO: PUT to news URI instead, need to modify form
-                  {:controller => 'news', :action => 'edit', :id => '567'},
-                  {:method => :post, :path => '/news/567/edit'}
-              end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
               end
               def test_post_edit
                 @request.session[:user_id] = 2
                 post :edit, :id => 1, :news => { :description => 'Description changed by test_post_edit' }
                 assert_redirected_to 'news/1'
                 news = News.find(1)
                 assert_equal 'Description changed by test_post_edit', news.description
               end
               def test_post_new_with_validation_failure
                 @request.session[:user_id] = 2
                 post :new, :project_id => 1, :news => { :title => '',
                                                         :description => 'This is the description',
                                                         :summary => '' }
                 assert_response :success
                 assert_template 'new'
                 assert_not_nil assigns(:news)
                 assert assigns(:news).new_record?
                 assert_tag :tag => 'div', :attributes => { :id => 'errorExplanation' },
                                           :content => /1 error/
               end
               def test_add_comment
                 @request.session[:user_id] = 2
                 post :add_comment, :id => 1, :comment => { :comments => 'This is a NewsControllerTest comment' }
                 assert_redirected_to 'news/1'
                 comment = News.find(1).comments.find(:first, :order => 'created_on DESC')
                 assert_not_nil comment
                 assert_equal 'This is a NewsControllerTest comment', comment.comments
                 assert_equal User.find(2), comment.author
               end
               def test_empty_comment_should_not_be_added
                 @request.session[:user_id] = 2
                 assert_no_difference 'Comment.count' do
                   post :add_comment, :id => 1, :comment => { :comments => '' }
                   assert_response :success
                   assert_template 'show'
                 end
               end
               def test_destroy_comment
                 comments_count = News.find(1).comments.size
                 @request.session[:user_id] = 2
                 post :destroy_comment, :id => 1, :comment_id => 2
                 assert_redirected_to 'news/1'
                 assert_nil Comment.find_by_id(2)
                 assert_equal comments_count - 1, News.find(1).comments.size
               end
-              def test_destroy_routing
-                assert_recognizes(#TODO: should use DELETE to news URI, need to change form
-                  {:controller => 'news', :action => 'destroy', :id => '567'},
-                  {:method => :post, :path => '/news/567/destroy'}
-              end
               def test_destroy
                 @request.session[:user_id] = 2
                 post :destroy, :id => 1
                 assert_redirected_to 'projects/ecookbook/news'
                 assert_nil News.find_by_id(1)
               end
               def test_preview
                 get :preview, :project_id => 1,
                               :news => {:title => '',
                                         :description => 'News description',
                                         :summary => ''}
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_tag :tag => 'fieldset', :attributes => { :class => 'preview' },
                                                :content => /News description/
               end
             end

test/functional/projects_controller_test.rb 0 -140

             # Redmine - project management software
             # Copyright (C) 2006-2008  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.dirname(__FILE__) + '/../test_helper'
             require 'projects_controller'
             # Re-raise errors caught by the controller.
             class ProjectsController; def rescue_action(e) raise e end; end
             class ProjectsControllerTest < ActionController::TestCase
               fixtures :projects, :versions, :users, :roles, :members, :member_roles, :issues, :journals, :journal_details,
                        :trackers, :projects_trackers, :issue_statuses, :enabled_modules, :enumerations, :boards, :messages,
                        :attachments, :custom_fields, :custom_values, :time_entries
               def setup
                 @controller = ProjectsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 @request.session[:user_id] = nil
                 Setting.default_language = 'en'
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects'},
-                  :controller => 'projects', :action => 'index'
-              end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:projects)
                 assert_tag :ul, :child => {:tag => 'li',
                                            :descendant => {:tag => 'a', :content => 'eCookbook'},
                                            :child => { :tag => 'ul',
                                                        :descendant => { :tag => 'a',
                                                                         :content => 'Child of private child'
                                                                        }
                                                       }
                                            }
                 assert_no_tag :a, :content => /Private child of eCookbook/
               end
-              def test_index_atom_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects.atom'},
-                  :controller => 'projects', :action => 'index', :format => 'atom'
-              end
               def test_index_atom
                 get :index, :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed.atom.rxml'
                 assert_select 'feed>title', :text => 'Redmine: Latest projects'
                 assert_select 'feed>entry', :count => Project.count(:conditions => Project.visible_by(User.current))
               end
-              def test_add_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/new'},
-                  :controller => 'projects', :action => 'add'
-                assert_recognizes(
-                  {:controller => 'projects', :action => 'add'},
-                  {:method => :post, :path => '/projects/new'}
-                assert_recognizes(
-                  {:controller => 'projects', :action => 'add'},
-                  {:method => :post, :path => '/projects'}
-              end
               context "#add" do
                 context "by admin user" do
                   setup do
                     @request.session[:user_id] = 1
                   end
                   should "accept get" do
                     get :add
                     assert_response :success
                     assert_template 'add'
                   end
                   should "accept post" do
                     post :add, :project => { :name => "blog",
                                              :description => "weblog",
                                              :identifier => "blog",
                                              :is_public => 1,
                                              :custom_field_values => { '3' => 'Beta' }
                                             }
                     assert_redirected_to '/projects/blog/settings'
                     project = Project.find_by_name('blog')
                     assert_kind_of Project, project
                     assert_equal 'weblog', project.description
                     assert_equal true, project.is_public?
                     assert_nil project.parent
                   end
                   should "accept post with parent" do
                     post :add, :project => { :name => "blog",
                                              :description => "weblog",
                                              :identifier => "blog",
                                              :is_public => 1,
                                              :custom_field_values => { '3' => 'Beta' },
                                              :parent_id => 1
                                             }
                     assert_redirected_to '/projects/blog/settings'
                     project = Project.find_by_name('blog')
                     assert_kind_of Project, project
                     assert_equal Project.find(1), project.parent
                   end
                 end
                 context "by non-admin user with add_project permission" do
                   setup do
                     Role.non_member.add_permission! :add_project
                     @request.session[:user_id] = 9
                   end
                   should "accept get" do
                     get :add
                     assert_response :success
                     assert_template 'add'
                     assert_no_tag :select, :attributes => {:name => 'project[parent_id]'}
                   end
                   should "accept post" do
                     post :add, :project => { :name => "blog",
                                              :description => "weblog",
                                              :identifier => "blog",
                                              :is_public => 1,
                                              :custom_field_values => { '3' => 'Beta' }
                                             }
                     assert_redirected_to '/projects/blog/settings'
                     project = Project.find_by_name('blog')
                     assert_kind_of Project, project
                     assert_equal 'weblog', project.description
                     assert_equal true, project.is_public?
                     # User should be added as a project member
                     assert User.find(9).member_of?(project)
                     assert_equal 1, project.members.size
                   end
                   should "fail with parent_id" do
                     assert_no_difference 'Project.count' do
                       post :add, :project => { :name => "blog",
                                                :description => "weblog",
                                                :identifier => "blog",
                                                :is_public => 1,
                                                :custom_field_values => { '3' => 'Beta' },
                                                :parent_id => 1
                                               }
                     end
                     assert_response :success
                     project = assigns(:project)
                     assert_kind_of Project, project
                     assert_not_nil project.errors.on(:parent_id)
                   end
                 end
                 context "by non-admin user with add_subprojects permission" do
                   setup do
                     Role.find(1).remove_permission! :add_project
                     Role.find(1).add_permission! :add_subprojects
                     @request.session[:user_id] = 2
                   end
                   should "accept get" do
                     get :add, :parent_id => 'ecookbook'
                     assert_response :success
                     assert_template 'add'
                     # parent project selected
                     assert_tag :select, :attributes => {:name => 'project[parent_id]'},
                                         :child => {:tag => 'option', :attributes => {:value => '1', :selected => 'selected'}}
                     # no empty value
                     assert_no_tag :select, :attributes => {:name => 'project[parent_id]'},
                                            :child => {:tag => 'option', :attributes => {:value => ''}}
                   end
                   should "accept post with parent_id" do
                     post :add, :project => { :name => "blog",
                                              :description => "weblog",
                                              :identifier => "blog",
                                              :is_public => 1,
                                              :custom_field_values => { '3' => 'Beta' },
                                              :parent_id => 1
                                             }
                     assert_redirected_to '/projects/blog/settings'
                     project = Project.find_by_name('blog')
                   end
                   should "fail without parent_id" do
                     assert_no_difference 'Project.count' do
                       post :add, :project => { :name => "blog",
                                                :description => "weblog",
                                                :identifier => "blog",
                                                :is_public => 1,
                                                :custom_field_values => { '3' => 'Beta' }
                                               }
                     end
                     assert_response :success
                     project = assigns(:project)
                     assert_kind_of Project, project
                     assert_not_nil project.errors.on(:parent_id)
                   end
                   should "fail with unauthorized parent_id" do
                     assert !User.find(2).member_of?(Project.find(6))
                     assert_no_difference 'Project.count' do
                       post :add, :project => { :name => "blog",
                                                :description => "weblog",
                                                :identifier => "blog",
                                                :is_public => 1,
                                                :custom_field_values => { '3' => 'Beta' },
                                                :parent_id => 6
                                               }
                     end
                     assert_response :success
                     project = assigns(:project)
                     assert_kind_of Project, project
                     assert_not_nil project.errors.on(:parent_id)
                   end
                 end
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/test'},
-                  :controller => 'projects', :action => 'show', :id => 'test'
-              end
               def test_show_by_id
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:project)
               end
               def test_show_by_identifier
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:project)
                 assert_equal Project.find_by_identifier('ecookbook'), assigns(:project)
               end
               def test_show_should_not_fail_when_custom_values_are_nil
                 project = Project.find_by_identifier('ecookbook')
                 project.custom_values.first.update_attribute(:value, nil)
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:project)
                 assert_equal Project.find_by_identifier('ecookbook'), assigns(:project)
               end
               def test_private_subprojects_hidden
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_no_tag :tag => 'a', :content => /Private child/
               end
               def test_private_subprojects_visible
                 @request.session[:user_id] = 2 # manager who is a member of the private subproject
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'a', :content => /Private child/
               end
-              def test_settings_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/4223/settings'},
-                  :controller => 'projects', :action => 'settings', :id => '4223'
-                assert_routing(
-                  {:method => :get, :path => '/projects/4223/settings/members'},
-                  :controller => 'projects', :action => 'settings', :id => '4223', :tab => 'members'
-              end
               def test_settings
                 @request.session[:user_id] = 2 # manager
                 get :settings, :id => 1
                 assert_response :success
                 assert_template 'settings'
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :post, :path => '/projects/4223/edit'},
-                  :controller => 'projects', :action => 'edit', :id => '4223'
-              end
               def test_edit
                 @request.session[:user_id] = 2 # manager
                 post :edit, :id => 1, :project => {:name => 'Test changed name',
                                                    :issue_custom_field_ids => ['']}
                 assert_redirected_to 'projects/ecookbook/settings'
                 project = Project.find(1)
                 assert_equal 'Test changed name', project.name
               end
-              def test_destroy_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/destroy'},
-                  :controller => 'projects', :action => 'destroy', :id => '567'
-                assert_routing(
-                #TODO: use DELETE and update form
-                  {:method => :post, :path => 'projects/64/destroy'},
-                  :controller => 'projects', :action => 'destroy', :id => '64'
-              end
               def test_get_destroy
                 @request.session[:user_id] = 1 # admin
                 get :destroy, :id => 1
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil Project.find_by_id(1)
               end
               def test_post_destroy
                 @request.session[:user_id] = 1 # admin
                 post :destroy, :id => 1, :confirm => 1
                 assert_redirected_to 'admin/projects'
                 assert_nil Project.find_by_id(1)
               end
               def test_add_file
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 Setting.notified_events = ['file_added']
                 ActionMailer::Base.deliveries.clear
                 assert_difference 'Attachment.count' do
                   post :add_file, :id => 1, :version_id => '',
                        :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 end
                 assert_redirected_to 'projects/ecookbook/files'
                 a = Attachment.find(:first, :order => 'created_on DESC')
                 assert_equal 'testfile.txt', a.filename
                 assert_equal Project.find(1), a.container
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert_equal "[eCookbook] New file", mail.subject
                 assert mail.body.include?('testfile.txt')
               end
-              def test_add_file_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/33/files/new'},
-                  :controller => 'projects', :action => 'add_file', :id => '33'
-                assert_routing(
-                  {:method => :post, :path => '/projects/33/files/new'},
-                  :controller => 'projects', :action => 'add_file', :id => '33'
-              end
               def test_add_version_file
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 Setting.notified_events = ['file_added']
                 assert_difference 'Attachment.count' do
                   post :add_file, :id => 1, :version_id => '2',
                        :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 end
                 assert_redirected_to 'projects/ecookbook/files'
                 a = Attachment.find(:first, :order => 'created_on DESC')
                 assert_equal 'testfile.txt', a.filename
                 assert_equal Version.find(2), a.container
               end
               def test_list_files
                 get :list_files, :id => 1
                 assert_response :success
                 assert_template 'list_files'
                 assert_not_nil assigns(:containers)
                 # file attached to the project
                 assert_tag :a, :content => 'project_file.zip',
                                :attributes => { :href => '/attachments/download/8/project_file.zip' }
                 # file attached to a project's version
                 assert_tag :a, :content => 'version_file.zip',
                                :attributes => { :href => '/attachments/download/9/version_file.zip' }
               end
-              def test_list_files_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/33/files'},
-                  :controller => 'projects', :action => 'list_files', :id => '33'
-              end
-              def test_roadmap_routing
-                assert_routing(
-                  {:method => :get, :path => 'projects/33/roadmap'},
-                  :controller => 'projects', :action => 'roadmap', :id => '33'
-              end
               def test_roadmap
                 get :roadmap, :id => 1
                 assert_response :success
                 assert_template 'roadmap'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version doesn't appear
                 assert !assigns(:versions).include?(Version.find(1))
               end
               def test_roadmap_with_completed_versions
                 get :roadmap, :id => 1, :completed => 1
                 assert_response :success
                 assert_template 'roadmap'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version appears
                 assert assigns(:versions).include?(Version.find(1))
               end
               def test_roadmap_showing_subprojects_versions
                 get :roadmap, :id => 1, :with_subprojects => 1
                 assert_response :success
                 assert_template 'roadmap'
                 assert_not_nil assigns(:versions)
                 # Version on subproject appears
                 assert assigns(:versions).include?(Version.find(4))
               end
-              def test_project_activity_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/1/activity'},
-                   :controller => 'projects', :action => 'activity', :id => '1'
-              end
-              def test_project_activity_atom_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/1/activity.atom'},
-                   :controller => 'projects', :action => 'activity', :id => '1', :format => 'atom'
-              end
               def test_project_activity
                 get :activity, :id => 1, :with_subprojects => 0
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{2.days.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue-edit/ },
                                :child => { :tag => "a",
                                  :content => /(#{IssueStatus.find(2).name})/,
                                }
                              }
                            }
               end
               def test_previous_project_activity
                 get :activity, :id => 1, :from => 3.days.ago.to_date
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{3.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(1).subject}/,
                                }
                              }
                            }
               end
-              def test_global_activity_routing
-                assert_routing({:method => :get, :path => '/activity'}, :controller => 'projects', :action => 'activity', :id => nil)
-              end
               def test_global_activity
                 get :activity
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{5.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(5).subject}/,
                                }
                              }
                            }
               end
               def test_user_activity
                 get :activity, :user_id => 2
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{3.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(1).subject}/,
                                }
                              }
                            }
               end
-              def test_global_activity_atom_routing
-                assert_routing({:method => :get, :path => '/activity.atom'}, :controller => 'projects', :action => 'activity', :id => nil, :format => 'atom')
-              end
               def test_activity_atom_feed
                 get :activity, :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed.atom.rxml'
               end
-              def test_archive_routing
-                assert_routing(
-                #TODO: use PUT to project path and modify form
-                  {:method => :post, :path => 'projects/64/archive'},
-                  :controller => 'projects', :action => 'archive', :id => '64'
-              end
               def test_archive
                 @request.session[:user_id] = 1 # admin
                 post :archive, :id => 1
                 assert_redirected_to 'admin/projects'
                 assert !Project.find(1).active?
               end
-              def test_unarchive_routing
-                assert_routing(
-                #TODO: use PUT to project path and modify form
-                  {:method => :post, :path => '/projects/567/unarchive'},
-                  :controller => 'projects', :action => 'unarchive', :id => '567'
-              end
               def test_unarchive
                 @request.session[:user_id] = 1 # admin
                 Project.find(1).archive
                 post :unarchive, :id => 1
                 assert_redirected_to 'admin/projects'
                 assert Project.find(1).active?
               end
               def test_project_breadcrumbs_should_be_limited_to_3_ancestors
                 CustomField.delete_all
                 parent = nil
 .times do |i|
                   p = Project.create!(:name => "Breadcrumbs #{i}", :identifier => "breadcrumbs-#{i}")
                   p.set_parent!(parent)
                   get :show, :id => p
                   assert_tag :h1, :parent => { :attributes => {:id => 'header'}},
                                   :children => { :count => [i, 3].min,
                                                  :only => { :tag => 'a' } }
                   parent = p
                 end
               end
               def test_copy_with_project
                 @request.session[:user_id] = 1 # admin
                 get :copy, :id => 1
                 assert_response :success
                 assert_template 'copy'
                 assert assigns(:project)
                 assert_equal Project.find(1).description, assigns(:project).description
                 assert_nil assigns(:project).id
               end
               def test_copy_without_project
                 @request.session[:user_id] = 1 # admin
                 get :copy
                 assert_response :redirect
                 assert_redirected_to :controller => 'admin', :action => 'projects'
               end
               def test_jump_should_redirect_to_active_tab
                 get :show, :id => 1, :jump => 'issues'
                 assert_redirected_to 'projects/ecookbook/issues'
               end
               def test_jump_should_not_redirect_to_inactive_tab
                 get :show, :id => 3, :jump => 'documents'
                 assert_response :success
                 assert_template 'show'
               end
               def test_jump_should_not_redirect_to_unknown_tab
                 get :show, :id => 3, :jump => 'foobar'
                 assert_response :success
                 assert_template 'show'
               end
-              def test_reset_activities_routing
-                assert_routing({:method => :delete, :path => 'projects/64/reset_activities'},
-                               :controller => 'projects', :action => 'reset_activities', :id => '64')
-              end
               def test_reset_activities
                 @request.session[:user_id] = 2 # manager
                 project_activity = TimeEntryActivity.new({
                                                            :name => 'Project Specific',
                                                            :parent => TimeEntryActivity.find(:first),
                                                            :project => Project.find(1),
                                                            :active => true
                                                          })
                 assert project_activity.save
                 project_activity_two = TimeEntryActivity.new({
                                                                :name => 'Project Specific Two',
                                                                :parent => TimeEntryActivity.find(:last),
                                                                :project => Project.find(1),
                                                                :active => true
                                                              })
                 assert project_activity_two.save
                 delete :reset_activities, :id => 1
                 assert_response :redirect
                 assert_redirected_to 'projects/ecookbook/settings/activities'
                 assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                 assert_nil TimeEntryActivity.find_by_id(project_activity_two.id)
               end
               def test_reset_activities_should_reassign_time_entries_back_to_the_system_activity
                 @request.session[:user_id] = 2 # manager
                 project_activity = TimeEntryActivity.new({
                                                            :name => 'Project Specific Design',
                                                            :parent => TimeEntryActivity.find(9),
                                                            :project => Project.find(1),
                                                            :active => true
                                                          })
                 assert project_activity.save
                 assert TimeEntry.update_all("activity_id = '#{project_activity.id}'", ["project_id = ? AND activity_id = ?", 1, 9])
                 assert 3, TimeEntry.find_all_by_activity_id_and_project_id(project_activity.id, 1).size
                 delete :reset_activities, :id => 1
                 assert_response :redirect
                 assert_redirected_to 'projects/ecookbook/settings/activities'
                 assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                 assert_equal 0, TimeEntry.find_all_by_activity_id_and_project_id(project_activity.id, 1).size, "TimeEntries still assigned to project specific activity"
                 assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "TimeEntries still assigned to project specific activity"
               end
-              def test_save_activities_routing
-                assert_routing({:method => :post, :path => 'projects/64/activities/save'},
-                               :controller => 'projects', :action => 'save_activities', :id => '64')
-              end
               def test_save_activities_to_override_system_activities
                 @request.session[:user_id] = 2 # manager
                 billable_field = TimeEntryActivityCustomField.find_by_name("Billable")
                 post :save_activities, :id => 1, :enumerations => {
                   "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # Design, De-activate
                   "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"}, # Development, Change custom value
                   "14"=>{"parent_id"=>"14", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"}, # Inactive Activity, Activate with custom value
                   "11"=>{"parent_id"=>"11", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"} # QA, no changes
                 }
                 assert_response :redirect
                 assert_redirected_to 'projects/ecookbook/settings/activities'
                 # Created project specific activities...
                 project = Project.find('ecookbook')
                 # ... Design
                 design = project.time_entry_activities.find_by_name("Design")
                 assert design, "Project activity not found"
                 assert_equal 9, design.parent_id # Relate to the system activity
                 assert_not_equal design.parent.id, design.id # Different records
                 assert_equal design.parent.name, design.name # Same name
                 assert !design.active?
                 # ... Development
                 development = project.time_entry_activities.find_by_name("Development")
                 assert development, "Project activity not found"
                 assert_equal 10, development.parent_id # Relate to the system activity
                 assert_not_equal development.parent.id, development.id # Different records
                 assert_equal development.parent.name, development.name # Same name
                 assert development.active?
                 assert_equal "0", development.custom_value_for(billable_field).value
                 # ... Inactive Activity
                 previously_inactive = project.time_entry_activities.find_by_name("Inactive Activity")
                 assert previously_inactive, "Project activity not found"
                 assert_equal 14, previously_inactive.parent_id # Relate to the system activity
                 assert_not_equal previously_inactive.parent.id, previously_inactive.id # Different records
                 assert_equal previously_inactive.parent.name, previously_inactive.name # Same name
                 assert previously_inactive.active?
                 assert_equal "1", previously_inactive.custom_value_for(billable_field).value
                 # ... QA
                 assert_equal nil, project.time_entry_activities.find_by_name("QA"), "Custom QA activity created when it wasn't modified"
               end
               def test_save_activities_will_update_project_specific_activities
                 @request.session[:user_id] = 2 # manager
                 project_activity = TimeEntryActivity.new({
                                                            :name => 'Project Specific',
                                                            :parent => TimeEntryActivity.find(:first),
                                                            :project => Project.find(1),
                                                            :active => true
                                                          })
                 assert project_activity.save
                 project_activity_two = TimeEntryActivity.new({
                                                                :name => 'Project Specific Two',
                                                                :parent => TimeEntryActivity.find(:last),
                                                                :project => Project.find(1),
                                                                :active => true
                                                              })
                 assert project_activity_two.save
                 post :save_activities, :id => 1, :enumerations => {
                   project_activity.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # De-activate
                   project_activity_two.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"} # De-activate
                 }
                 assert_response :redirect
                 assert_redirected_to 'projects/ecookbook/settings/activities'
                 # Created project specific activities...
                 project = Project.find('ecookbook')
                 assert_equal 2, project.time_entry_activities.count
                 activity_one = project.time_entry_activities.find_by_name(project_activity.name)
                 assert activity_one, "Project activity not found"
                 assert_equal project_activity.id, activity_one.id
                 assert !activity_one.active?
                 activity_two = project.time_entry_activities.find_by_name(project_activity_two.name)
                 assert activity_two, "Project activity not found"
                 assert_equal project_activity_two.id, activity_two.id
                 assert !activity_two.active?
               end
               def test_save_activities_when_creating_new_activities_will_convert_existing_data
                 assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size
                 @request.session[:user_id] = 2 # manager
                 post :save_activities, :id => 1, :enumerations => {
                   "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"} # Design, De-activate
                 }
                 assert_response :redirect
                 # No more TimeEntries using the system activity
                 assert_equal 0, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "Time Entries still assigned to system activities"
                 # All TimeEntries using project activity
                 project_specific_activity = TimeEntryActivity.find_by_parent_id_and_project_id(9, 1)
                 assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(project_specific_activity.id, 1).size, "No Time Entries assigned to the project activity"
               end
               def test_save_activities_when_creating_new_activities_will_not_convert_existing_data_if_an_exception_is_raised
                 # TODO: Need to cause an exception on create but these tests
                 # aren't setup for mocking.  Just create a record now so the
                 # second one is a dupicate
                 parent = TimeEntryActivity.find(9)
                 TimeEntryActivity.create!({:name => parent.name, :project_id => 1, :position => parent.position, :active => true})
                 TimeEntry.create!({:project_id => 1, :hours => 1.0, :user => User.find(1), :issue_id => 3, :activity_id => 10, :spent_on => '2009-01-01'})
                 assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size
                 assert_equal 1, TimeEntry.find_all_by_activity_id_and_project_id(10, 1).size
                 @request.session[:user_id] = 2 # manager
                 post :save_activities, :id => 1, :enumerations => {
                   "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # Design
                   "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"} # Development, Change custom value
                 }
                 assert_response :redirect
                 # TimeEntries shouldn't have been reassigned on the failed record
                 assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "Time Entries are not assigned to system activities"
                 # TimeEntries shouldn't have been reassigned on the saved record either
                 assert_equal 1, TimeEntry.find_all_by_activity_id_and_project_id(10, 1).size, "Time Entries are not assigned to system activities"
               end
               # A hook that is manually registered later
               class ProjectBasedTemplate < Redmine::Hook::ViewListener
                 def view_layouts_base_html_head(context)
                   # Adds a project stylesheet
                   stylesheet_link_tag(context[:project].identifier) if context[:project]
                 end
               end
               # Don't use this hook now
               Redmine::Hook.clear_listeners
               def test_hook_response
                 Redmine::Hook.add_listener(ProjectBasedTemplate)
                 get :show, :id => 1
                 assert_tag :tag => 'link', :attributes => {:href => '/stylesheets/ecookbook.css'},
                                            :parent => {:tag => 'head'}
                 Redmine::Hook.clear_listeners
               end
             end

test/functional/repositories_controller_test.rb 0 -123

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'repositories_controller'
             # Re-raise errors caught by the controller.
             class RepositoriesController; def rescue_action(e) raise e end; end
             class RepositoriesControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :repositories, :issues, :issue_statuses, :changesets, :changes, :issue_categories, :enumerations, :custom_fields, :custom_values, :trackers
               def setup
                 @controller = RepositoriesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/redmine/repository'},
-                  :controller => 'repositories', :action => 'show', :id => 'redmine'
-              end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/world_domination/repository/edit'},
-                  :controller => 'repositories', :action => 'edit', :id => 'world_domination'
-                assert_routing(
-                  {:method => :post, :path => '/projects/world_domination/repository/edit'},
-                  :controller => 'repositories', :action => 'edit', :id => 'world_domination'
-              end
-              def test_revisions_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/redmine/repository/revisions'},
-                  :controller => 'repositories', :action => 'revisions', :id => 'redmine'
-              end
-              def test_revisions_atom_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/redmine/repository/revisions.atom'},
-                  :controller => 'repositories', :action => 'revisions', :id => 'redmine', :format => 'atom'
-              end
               def test_revisions
                 get :revisions, :id => 1
                 assert_response :success
                 assert_template 'revisions'
                 assert_not_nil assigns(:changesets)
               end
-              def test_revision_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2457'},
-                  :controller => 'repositories', :action => 'revision', :id => 'restmine', :rev => '2457'
-              end
               def test_revision
                 get :revision, :id => 1, :rev => 1
                 assert_response :success
                 assert_not_nil assigns(:changeset)
                 assert_equal "1", assigns(:changeset).revision
               end
               def test_revision_with_before_nil_and_afer_normal
                 get :revision, {:id => 1, :rev => 1}
                 assert_response :success
                 assert_template 'revision'
                 assert_no_tag :tag => "div", :attributes => { :class => "contextual" },
                   :child => { :tag => "a", :attributes => { :href => '/projects/ecookbook/repository/revisions/0'}
                 }
                 assert_tag :tag => "div", :attributes => { :class => "contextual" },
                     :child => { :tag => "a", :attributes => { :href => '/projects/ecookbook/repository/revisions/2'}
                 }
               end
-              def test_diff_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2457/diff'},
-                  :controller => 'repositories', :action => 'diff', :id => 'restmine', :rev => '2457'
-              end
-              def test_unified_diff_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2457/diff.diff'},
-                  :controller => 'repositories', :action => 'diff', :id => 'restmine', :rev => '2457', :format => 'diff'
-              end
-              def test_diff_path_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/diff/path/to/file.c'},
-                  :controller => 'repositories', :action => 'diff', :id => 'restmine', :path => %w[path to file.c]
-              end
-              def test_diff_path_routing_with_revision
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2/diff/path/to/file.c'},
-                  :controller => 'repositories', :action => 'diff', :id => 'restmine', :path => %w[path to file.c], :rev => '2'
-              end
-              def test_browse_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/browse/path/to/dir'},
-                  :controller => 'repositories', :action => 'browse', :id => 'restmine', :path => %w[path to dir]
-              end
-              def test_entry_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/entry/path/to/file.c'},
-                  :controller => 'repositories', :action => 'entry', :id => 'restmine', :path => %w[path to file.c]
-              end
-              def test_entry_routing_with_revision
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2/entry/path/to/file.c'},
-                  :controller => 'repositories', :action => 'entry', :id => 'restmine', :path => %w[path to file.c], :rev => '2'
-              end
-              def test_raw_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/raw/path/to/file.c'},
-                  :controller => 'repositories', :action => 'entry', :id => 'restmine', :path => %w[path to file.c], :format => 'raw'
-              end
-              def test_raw_routing_with_revision
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/revisions/2/raw/path/to/file.c'},
-                  :controller => 'repositories', :action => 'entry', :id => 'restmine', :path => %w[path to file.c], :format => 'raw', :rev => '2'
-              end
-              def test_annotate_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/annotate/path/to/file.c'},
-                  :controller => 'repositories', :action => 'annotate', :id => 'restmine', :path => %w[path to file.c]
-              end
-              def test_changesrouting
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/changes/path/to/file.c'},
-                  :controller => 'repositories', :action => 'changes', :id => 'restmine', :path => %w[path to file.c]
-              end
-              def test_statistics_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/restmine/repository/statistics'},
-                  :controller => 'repositories', :action => 'stats', :id => 'restmine'
-              end
               def test_graph_commits_per_month
                 get :graph, :id => 1, :graph => 'commits_per_month'
                 assert_response :success
                 assert_equal 'image/svg+xml', @response.content_type
               end
               def test_graph_commits_per_author
                 get :graph, :id => 1, :graph => 'commits_per_author'
                 assert_response :success
                 assert_equal 'image/svg+xml', @response.content_type
               end
               def test_committers
                 @request.session[:user_id] = 2
                 # add a commit with an unknown user
                 Changeset.create!(:repository => Project.find(1).repository, :committer => 'foo', :committed_on => Time.now, :revision => 100, :comments => 'Committed by foo.')
                 get :committers, :id => 1
                 assert_response :success
                 assert_template 'committers'
                 assert_tag :td, :content => 'dlopper',
                                 :sibling => { :tag => 'td',
                                               :child => { :tag => 'select', :attributes => { :name => %r{^committers\[\d+\]\[\]$} },
                                                                             :child => { :tag => 'option', :content => 'Dave Lopper',
                                                                                                           :attributes => { :value => '3', :selected => 'selected' }}}}
                 assert_tag :td, :content => 'foo',
                                 :sibling => { :tag => 'td',
                                               :child => { :tag => 'select', :attributes => { :name => %r{^committers\[\d+\]\[\]$} }}}
                 assert_no_tag :td, :content => 'foo',
                                    :sibling => { :tag => 'td',
                                                  :descendant => { :tag => 'option', :attributes => { :selected => 'selected' }}}
               end
               def test_map_committers
                 @request.session[:user_id] = 2
                 # add a commit with an unknown user
                 c = Changeset.create!(:repository => Project.find(1).repository, :committer => 'foo', :committed_on => Time.now, :revision => 100, :comments => 'Committed by foo.')
                 assert_no_difference "Changeset.count(:conditions => 'user_id = 3')" do
                   post :committers, :id => 1, :committers => { '0' => ['foo', '2'], '1' => ['dlopper', '3']}
                   assert_redirected_to 'projects/ecookbook/repository/committers'
                   assert_equal User.find(2), c.reload.user
                 end
               end
             end

test/functional/timelog_controller_test.rb 0 -105

             # -*- coding: utf-8 -*-
             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'timelog_controller'
             # Re-raise errors caught by the controller.
             class TimelogController; def rescue_action(e) raise e end; end
             class TimelogControllerTest < ActionController::TestCase
               fixtures :projects, :enabled_modules, :roles, :members, :member_roles, :issues, :time_entries, :users, :trackers, :enumerations, :issue_statuses, :custom_fields, :custom_values
               def setup
                 @controller = TimelogController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
               end
-              def test_edit_routing
-                assert_routing(
-                  {:method => :get, :path => '/issues/567/time_entries/new'},
-                  :controller => 'timelog', :action => 'edit', :issue_id => '567'
-                assert_routing(
-                  {:method => :get, :path => '/projects/ecookbook/time_entries/new'},
-                  :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook'
-                assert_routing(
-                  {:method => :get, :path => '/projects/ecookbook/issues/567/time_entries/new'},
-                  :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook', :issue_id => '567'
-                #TODO: change new form to POST to issue_time_entries_path instead of to edit action
-                #TODO: change edit form to PUT to time_entry_path
-                assert_routing(
-                  {:method => :get, :path => '/time_entries/22/edit'},
-                  :controller => 'timelog', :action => 'edit', :id => '22'
-              end
               def test_get_edit
                 @request.session[:user_id] = 3
                 get :edit, :project_id => 1
                 assert_response :success
                 assert_template 'edit'
                 # Default activity selected
                 assert_tag :tag => 'option', :attributes => { :selected => 'selected' },
                                              :content => 'Development'
               end
               def test_get_edit_existing_time
                 @request.session[:user_id] = 2
                 get :edit, :id => 2, :project_id => nil
                 assert_response :success
                 assert_template 'edit'
                 # Default activity selected
                 assert_tag :tag => 'form', :attributes => { :action => '/projects/ecookbook/timelog/edit/2' }
               end
               def test_get_edit_should_only_show_active_time_entry_activities
                 @request.session[:user_id] = 3
                 get :edit, :project_id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_no_tag :tag => 'option', :content => 'Inactive Activity'
               end
               def test_get_edit_with_an_existing_time_entry_with_inactive_activity
                 te = TimeEntry.find(1)
                 te.activity = TimeEntryActivity.find_by_name("Inactive Activity")
                 te.save!
                 @request.session[:user_id] = 1
                 get :edit, :project_id => 1, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 # Blank option since nothing is pre-selected
                 assert_tag :tag => 'option', :content => '--- Please select ---'
               end
               def test_post_edit
                 # TODO: should POST to issues’ time log instead of project. change form
                 # and routing
                 @request.session[:user_id] = 3
                 post :edit, :project_id => 1,
                             :time_entry => {:comments => 'Some work on TimelogControllerTest',
                                             # Not the default activity
                                             :activity_id => '11',
                                             :spent_on => '2008-03-14',
                                             :issue_id => '1',
                                             :hours => '7.3'}
                 assert_redirected_to :action => 'details', :project_id => 'ecookbook'
                 i = Issue.find(1)
                 t = TimeEntry.find_by_comments('Some work on TimelogControllerTest')
                 assert_not_nil t
                 assert_equal 11, t.activity_id
                 assert_equal 7.3, t.hours
                 assert_equal 3, t.user_id
                 assert_equal i, t.issue
                 assert_equal i.project, t.project
               end
               def test_update
                 entry = TimeEntry.find(1)
                 assert_equal 1, entry.issue_id
                 assert_equal 2, entry.user_id
                 @request.session[:user_id] = 1
                 post :edit, :id => 1,
                             :time_entry => {:issue_id => '2',
                                             :hours => '8'}
                 assert_redirected_to :action => 'details', :project_id => 'ecookbook'
                 entry.reload
                 assert_equal 8, entry.hours
                 assert_equal 2, entry.issue_id
                 assert_equal 2, entry.user_id
               end
-              def test_destroy_routing
-                #TODO: use DELETE to time_entry_path
-                assert_routing(
-                  {:method => :post, :path => '/time_entries/55/destroy'},
-                  :controller => 'timelog', :action => 'destroy', :id => '55'
-              end
               def test_destroy
                 @request.session[:user_id] = 2
                 post :destroy, :id => 1
                 assert_redirected_to :action => 'details', :project_id => 'ecookbook'
                 assert_nil TimeEntry.find_by_id(1)
               end
-              def test_report_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/time_entries/report'},
-                  :controller => 'timelog', :action => 'report', :project_id => '567'
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/time_entries/report.csv'},
-                  :controller => 'timelog', :action => 'report', :project_id => '567', :format => 'csv'
-              end
               def test_report_no_criteria
                 get :report, :project_id => 1
                 assert_response :success
                 assert_template 'report'
               end
-              def test_report_routing_for_all_projects
-                assert_routing(
-                  {:method => :get, :path => '/time_entries/report'},
-                  :controller => 'timelog', :action => 'report'
-              end
               def test_report_all_projects
                 get :report
                 assert_response :success
                 assert_template 'report'
               end
               def test_report_all_projects_denied
                 r = Role.anonymous
                 r.permissions.delete(:view_time_entries)
                 r.permissions_will_change!
                 r.save
                 get :report
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Ftime_entries%2Freport'
               end
               def test_report_all_projects_one_criteria
                 get :report, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criterias => ['project']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "8.65", "%.2f" % assigns(:total_hours)
               end
               def test_report_all_time
                 get :report, :project_id => 1, :criterias => ['project', 'issue']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
               end
               def test_report_all_time_by_day
                 get :report, :project_id => 1, :criterias => ['project', 'issue'], :columns => 'day'
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 assert_tag :tag => 'th', :content => '2007-03-12'
               end
               def test_report_one_criteria
                 get :report, :project_id => 1, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criterias => ['project']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "8.65", "%.2f" % assigns(:total_hours)
               end
               def test_report_two_criterias
                 get :report, :project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criterias => ["member", "activity"]
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
               end
               def test_report_one_day
                 get :report, :project_id => 1, :columns => 'day', :from => "2007-03-23", :to => "2007-03-23", :criterias => ["member", "activity"]
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "4.25", "%.2f" % assigns(:total_hours)
               end
               def test_report_at_issue_level
                 get :report, :project_id => 1, :issue_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criterias => ["member", "activity"]
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "154.25", "%.2f" % assigns(:total_hours)
               end
               def test_report_custom_field_criteria
                 get :report, :project_id => 1, :criterias => ['project', 'cf_1', 'cf_7']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_not_nil assigns(:criterias)
                 assert_equal 3, assigns(:criterias).size
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 # Custom field column
                 assert_tag :tag => 'th', :content => 'Database'
                 # Custom field row
                 assert_tag :tag => 'td', :content => 'MySQL',
                                          :sibling => { :tag => 'td', :attributes => { :class => 'hours' },
                                                                      :child => { :tag => 'span', :attributes => { :class => 'hours hours-int' },
                                                                                                  :content => '1' }}
                 # Second custom field column
                 assert_tag :tag => 'th', :content => 'Billable'
               end
               def test_report_one_criteria_no_result
                 get :report, :project_id => 1, :columns => 'week', :from => "1998-04-01", :to => "1998-04-30", :criterias => ['project']
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "0.00", "%.2f" % assigns(:total_hours)
               end
               def test_report_all_projects_csv_export
                 get :report, :columns => 'month', :from => "2007-01-01", :to => "2007-06-30", :criterias => ["project", "member", "activity"], :format => "csv"
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 assert_equal 'Project,Member,Activity,2007-1,2007-2,2007-3,2007-4,2007-5,2007-6,Total', lines.first
                 # Total row
                 assert_equal 'Total,"","","","",154.25,8.65,"","",162.90', lines.last
               end
               def test_report_csv_export
                 get :report, :project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-06-30", :criterias => ["project", "member", "activity"], :format => "csv"
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 assert_equal 'Project,Member,Activity,2007-1,2007-2,2007-3,2007-4,2007-5,2007-6,Total', lines.first
                 # Total row
                 assert_equal 'Total,"","","","",154.25,8.65,"","",162.90', lines.last
               end
               def test_details_all_projects
                 get :details
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
               end
-              def test_project_details_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/time_entries'},
-                  :controller => 'timelog', :action => 'details', :project_id => '567'
-              end
               def test_details_at_project_level
                 get :details, :project_id => 1
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 4, assigns(:entries).size
                 # project and subproject
                 assert_equal [1, 3], assigns(:entries).collect(&:project_id).uniq.sort
                 assert_not_nil assigns(:total_hours)
                 assert_equal "162.90", "%.2f" % assigns(:total_hours)
                 # display all time by default
                 assert_equal '2007-03-11'.to_date, assigns(:from)
                 assert_equal '2007-04-22'.to_date, assigns(:to)
               end
               def test_details_at_project_level_with_date_range
                 get :details, :project_id => 1, :from => '2007-03-20', :to => '2007-04-30'
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 3, assigns(:entries).size
                 assert_not_nil assigns(:total_hours)
                 assert_equal "12.90", "%.2f" % assigns(:total_hours)
                 assert_equal '2007-03-20'.to_date, assigns(:from)
                 assert_equal '2007-04-30'.to_date, assigns(:to)
               end
               def test_details_at_project_level_with_period
                 get :details, :project_id => 1, :period => '7_days'
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_not_nil assigns(:total_hours)
                 assert_equal Date.today - 7, assigns(:from)
                 assert_equal Date.today, assigns(:to)
               end
               def test_details_one_day
                 get :details, :project_id => 1, :from => "2007-03-23", :to => "2007-03-23"
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:total_hours)
                 assert_equal "4.25", "%.2f" % assigns(:total_hours)
               end
-              def test_issue_details_routing
-                assert_routing(
-                  {:method => :get, :path => 'time_entries'},
-                  :controller => 'timelog', :action => 'details'
-                assert_routing(
-                  {:method => :get, :path => '/issues/234/time_entries'},
-                  :controller => 'timelog', :action => 'details', :issue_id => '234'
-                # TODO: issue detail page shouldnt link to project_issue_time_entries_path but to normal issues one
-                # doesnt seem to have effect on resulting page so controller can be left untouched
-                assert_routing(
-                  {:method => :get, :path => '/projects/ecookbook/issues/123/time_entries'},
-                  :controller => 'timelog', :action => 'details', :project_id => 'ecookbook', :issue_id => '123'
-              end
               def test_details_at_issue_level
                 get :details, :issue_id => 1
                 assert_response :success
                 assert_template 'details'
                 assert_not_nil assigns(:entries)
                 assert_equal 2, assigns(:entries).size
                 assert_not_nil assigns(:total_hours)
                 assert_equal 154.25, assigns(:total_hours)
                 # display all time by default
                 assert_equal '2007-03-11'.to_date, assigns(:from)
                 assert_equal '2007-04-22'.to_date, assigns(:to)
               end
-              def test_details_formatted_routing
-                assert_routing(
-                  {:method => :get, :path => 'time_entries.atom'},
-                  :controller => 'timelog', :action => 'details', :format => 'atom'
-                assert_routing(
-                  {:method => :get, :path => 'time_entries.csv'},
-                  :controller => 'timelog', :action => 'details', :format => 'csv'
-              end
-              def test_details_for_project_formatted_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/time_entries.atom'},
-                  :controller => 'timelog', :action => 'details', :format => 'atom', :project_id => '567'
-                assert_routing(
-                  {:method => :get, :path => '/projects/567/time_entries.csv'},
-                  :controller => 'timelog', :action => 'details', :format => 'csv', :project_id => '567'
-              end
-              def test_details_for_issue_formatted_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/ecookbook/issues/123/time_entries.atom'},
-                  :controller => 'timelog', :action => 'details', :project_id => 'ecookbook', :issue_id => '123', :format => 'atom'
-                assert_routing(
-                  {:method => :get, :path => '/projects/ecookbook/issues/123/time_entries.csv'},
-                  :controller => 'timelog', :action => 'details', :project_id => 'ecookbook', :issue_id => '123', :format => 'csv'
-              end
               def test_details_atom_feed
                 get :details, :project_id => 1, :format => 'atom'
                 assert_response :success
                 assert_equal 'application/atom+xml', @response.content_type
                 assert_not_nil assigns(:items)
                 assert assigns(:items).first.is_a?(TimeEntry)
               end
               def test_details_all_projects_csv_export
                 Setting.date_format = '%m/%d/%Y'
                 get :details, :format => 'csv'
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.include?("Date,User,Activity,Project,Issue,Tracker,Subject,Hours,Comment\n")
                 assert @response.body.include?("\n04/21/2007,redMine Admin,Design,eCookbook,3,Bug,Error 281 when updating a recipe,1.0,\"\"\n")
               end
               def test_details_csv_export
                 Setting.date_format = '%m/%d/%Y'
                 get :details, :project_id => 1, :format => 'csv'
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.include?("Date,User,Activity,Project,Issue,Tracker,Subject,Hours,Comment\n")
                 assert @response.body.include?("\n04/21/2007,redMine Admin,Design,eCookbook,3,Bug,Error 281 when updating a recipe,1.0,\"\"\n")
               end
             end

test/functional/wikis_controller_test.rb 0 -19

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../test_helper'
             require 'wikis_controller'
             # Re-raise errors caught by the controller.
             class WikisController; def rescue_action(e) raise e end; end
             class WikisControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules, :wikis
               def setup
                 @controller = WikisController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
-              def test_edit_routing
-                assert_routing(
-                #TODO: use PUT
-                  {:method => :post, :path => 'projects/ladida/wiki'},
-                  :controller => 'wikis', :action => 'edit', :id => 'ladida'
-              end
               def test_create
                 @request.session[:user_id] = 1
                 assert_nil Project.find(3).wiki
                 post :edit, :id => 3, :wiki => { :start_page => 'Start page' }
                 assert_response :success
                 wiki = Project.find(3).wiki
                 assert_not_nil wiki
                 assert_equal 'Start page', wiki.start_page
               end
-              def test_destroy_routing
-                assert_routing(
-                  {:method => :get, :path => 'projects/ladida/wiki/destroy'},
-                  :controller => 'wikis', :action => 'destroy', :id => 'ladida'
-                assert_recognizes(  #TODO: use DELETE and update form
-                  {:controller => 'wikis', :action => 'destroy', :id => 'ladida'},
-                  {:method => :post, :path => 'projects/ladida/wiki/destroy'}
-              end
               def test_destroy
                 @request.session[:user_id] = 1
                 post :destroy, :id => 1, :confirm => 1
                 assert_redirected_to :controller => 'projects', :action => 'settings', :id => 'ecookbook', :tab => 'wiki'
                 assert_nil Project.find(1).wiki
               end
               def test_not_found
                 @request.session[:user_id] = 1
                 post :destroy, :id => 999, :confirm => 1
                 assert_response 404
               end
             end

test/integration/issues_api_test.rb 0 -35

             # Redmine - project management software
             # Copyright (C) 2006-2010  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.dirname(__FILE__)}/../test_helper"
             class IssuesApiTest < 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
               def setup
                 Setting.rest_api_enabled = '1'
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/issues.xml'},
-                  :controller => 'issues', :action => 'index', :format => 'xml'
-              end
               def test_index
                 get '/issues.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
               end
               def test_index_with_filter
                 get '/issues.xml?status_id=5'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :tag => 'issues',
                            :children => { :count => Issue.visible.count(:conditions => {:status_id => 5}),
                                           :only => { :tag => 'issue' } }
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/issues/1.xml'},
-                  :controller => 'issues', :action => 'show', :id => '1', :format => 'xml'
-              end
               def test_show
                 get '/issues/1.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
               end
-              def test_create_routing
-                assert_routing(
-                  {:method => :post, :path => '/issues.xml'},
-                  :controller => 'issues', :action => 'new', :format => 'xml'
-              end
               def test_create
                 attributes = {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}
                 assert_difference 'Issue.count' do
                   post '/issues.xml', {:issue => attributes}, :authorization => credentials('jsmith')
                 end
                 assert_response :created
                 assert_equal 'application/xml', @response.content_type
                 issue = Issue.first(:order => 'id DESC')
                 attributes.each do |attribute, value|
                   assert_equal value, issue.send(attribute)
                 end
               end
               def test_create_failure
                 attributes = {:project_id => 1}
                 assert_no_difference 'Issue.count' do
                   post '/issues.xml', {:issue => attributes}, :authorization => credentials('jsmith')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
               end
-              def test_update_routing
-                assert_routing(
-                  {:method => :put, :path => '/issues/1.xml'},
-                  :controller => 'issues', :action => 'update', :id => '1', :format => 'xml'
-              end
               def test_update
                 attributes = {:subject => 'API update'}
                 assert_no_difference 'Issue.count' do
                   assert_difference 'Journal.count' do
                     put '/issues/1.xml', {:issue => attributes}, :authorization => credentials('jsmith')
                   end
                 end
                 assert_response :ok
                 assert_equal 'application/xml', @response.content_type
                 issue = Issue.find(1)
                 attributes.each do |attribute, value|
                   assert_equal value, issue.send(attribute)
                 end
               end
               def test_update_failure
                 attributes = {:subject => ''}
                 assert_no_difference 'Issue.count' do
                   assert_no_difference 'Journal.count' do
                     put '/issues/1.xml', {:issue => attributes}, :authorization => credentials('jsmith')
                   end
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
               end
-              def test_destroy_routing
-                assert_routing(
-                  {:method => :delete, :path => '/issues/1.xml'},
-                  :controller => 'issues', :action => 'destroy', :id => '1', :format => 'xml'
-              end
               def test_destroy
                 assert_difference 'Issue.count', -1 do
                   delete '/issues/1.xml', {}, :authorization => credentials('jsmith')
                 end
                 assert_response :ok
                 assert_equal 'application/xml', @response.content_type
                 assert_nil Issue.find_by_id(1)
               end
               def credentials(user, password=nil)
                 ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)
               end
             end

test/integration/projects_api_test.rb 0 -35

             # Redmine - project management software
             # Copyright (C) 2006-2010  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.dirname(__FILE__)}/../test_helper"
             class ProjectsApiTest < ActionController::IntegrationTest
               fixtures :projects, :versions, :users, :roles, :members, :member_roles, :issues, :journals, :journal_details,
                        :trackers, :projects_trackers, :issue_statuses, :enabled_modules, :enumerations, :boards, :messages,
                        :attachments, :custom_fields, :custom_values, :time_entries
               def setup
                 Setting.rest_api_enabled = '1'
               end
-              def test_index_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects.xml'},
-                  :controller => 'projects', :action => 'index', :format => 'xml'
-              end
               def test_index
                 get '/projects.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
               end
-              def test_show_routing
-                assert_routing(
-                  {:method => :get, :path => '/projects/1.xml'},
-                  :controller => 'projects', :action => 'show', :id => '1', :format => 'xml'
-              end
               def test_show
                 get '/projects/1.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
               end
-              def test_create_routing
-                assert_routing(
-                  {:method => :post, :path => '/projects.xml'},
-                  :controller => 'projects', :action => 'add', :format => 'xml'
-              end
               def test_create
                 attributes = {:name => 'API test', :identifier => 'api-test'}
                 assert_difference 'Project.count' do
                   post '/projects.xml', {:project => attributes}, :authorization => credentials('admin')
                 end
                 assert_response :created
                 assert_equal 'application/xml', @response.content_type
                 project = Project.first(:order => 'id DESC')
                 attributes.each do |attribute, value|
                   assert_equal value, project.send(attribute)
                 end
               end
               def test_create_failure
                 attributes = {:name => 'API test'}
                 assert_no_difference 'Project.count' do
                   post '/projects.xml', {:project => attributes}, :authorization => credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :errors, :child => {:tag => 'error', :content => "Identifier can't be blank"}
               end
-              def test_update_routing
-                assert_routing(
-                  {:method => :put, :path => '/projects/1.xml'},
-                  :controller => 'projects', :action => 'edit', :id => '1', :format => 'xml'
-              end
               def test_update
                 attributes = {:name => 'API update'}
                 assert_no_difference 'Project.count' do
                   put '/projects/1.xml', {:project => attributes}, :authorization => credentials('jsmith')
                 end
                 assert_response :ok
                 assert_equal 'application/xml', @response.content_type
                 project = Project.find(1)
                 attributes.each do |attribute, value|
                   assert_equal value, project.send(attribute)
                 end
               end
               def test_update_failure
                 attributes = {:name => ''}
                 assert_no_difference 'Project.count' do
                   put '/projects/1.xml', {:project => attributes}, :authorization => credentials('jsmith')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_tag :errors, :child => {:tag => 'error', :content => "Name can't be blank"}
               end
-              def test_destroy_routing
-                assert_routing(
-                  {:method => :delete, :path => '/projects/1.xml'},
-                  :controller => 'projects', :action => 'destroy', :id => '1', :format => 'xml'
-              end
               def test_destroy
                 assert_difference 'Project.count', -1 do
                   delete '/projects/2.xml', {}, :authorization => credentials('admin')
                 end
                 assert_response :ok
                 assert_equal 'application/xml', @response.content_type
                 assert_nil Project.find_by_id(2)
               end
               def credentials(user, password=nil)
                 ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)
               end
             end

test/integration/routing_test.rb +167 -1

             # redMine - project management software
             # Copyright (C) 2006-2010  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.dirname(__FILE__)}/../test_helper"
             class RoutingTest < ActionController::IntegrationTest
+              context "activities" do
+                should_route :get, "/activity", :controller => 'projects', :action => 'activity', :id => nil
+                should_route :get, "/activity.atom", :controller => 'projects', :action => 'activity', :id => nil, :format => 'atom'
+              end
+              context "attachments" do
+                should_route :get, "/attachments/1", :controller => 'attachments', :action => 'show', :id => '1'
+                should_route :get, "/attachments/1/filename.ext", :controller => 'attachments', :action => 'show', :id => '1', :filename => 'filename.ext'
+                should_route :get, "/attachments/download/1", :controller => 'attachments', :action => 'download', :id => '1'
+                should_route :get, "/attachments/download/1/filename.ext", :controller => 'attachments', :action => 'download', :id => '1', :filename => 'filename.ext'
+              end
+              context "boards" do
+                should_route :get, "/projects/world_domination/boards", :controller => 'boards', :action => 'index', :project_id => 'world_domination'
+                should_route :get, "/projects/world_domination/boards/new", :controller => 'boards', :action => 'new', :project_id => 'world_domination'
+                should_route :get, "/projects/world_domination/boards/44", :controller => 'boards', :action => 'show', :project_id => 'world_domination', :id => '44'
+                should_route :get, "/projects/world_domination/boards/44.atom", :controller => 'boards', :action => 'show', :project_id => 'world_domination', :id => '44', :format => 'atom'
+                should_route :get, "/projects/world_domination/boards/44/edit", :controller => 'boards', :action => 'edit', :project_id => 'world_domination', :id => '44'
+                should_route :post, "/projects/world_domination/boards/new", :controller => 'boards', :action => 'new', :project_id => 'world_domination'
+                should_route :post, "/projects/world_domination/boards/44/edit", :controller => 'boards', :action => 'edit', :project_id => 'world_domination', :id => '44'
+                should_route :post, "/projects/world_domination/boards/44/destroy", :controller => 'boards', :action => 'destroy', :project_id => 'world_domination', :id => '44'
+              end
+              context "documents" do
+                should_route :get, "/projects/567/documents", :controller => 'documents', :action => 'index', :project_id => '567'
+                should_route :get, "/projects/567/documents/new", :controller => 'documents', :action => 'new', :project_id => '567'
+                should_route :get, "/documents/22", :controller => 'documents', :action => 'show', :id => '22'
+                should_route :get, "/documents/22/edit", :controller => 'documents', :action => 'edit', :id => '22'
+                should_route :post, "/projects/567/documents/new", :controller => 'documents', :action => 'new', :project_id => '567'
+                should_route :post, "/documents/567/edit", :controller => 'documents', :action => 'edit', :id => '567'
+                should_route :post, "/documents/567/destroy", :controller => 'documents', :action => 'destroy', :id => '567'
+              end
               context "issues" do
                 # REST actions
                 should_route :get, "/issues", :controller => 'issues', :action => 'index'
                 should_route :get, "/issues.pdf", :controller => 'issues', :action => 'index', :format => 'pdf'
                 should_route :get, "/issues.atom", :controller => 'issues', :action => 'index', :format => 'atom'
                 should_route :get, "/issues.xml", :controller => 'issues', :action => 'index', :format => 'xml'
                 should_route :get, "/projects/23/issues", :controller => 'issues', :action => 'index', :project_id => '23'
                 should_route :get, "/projects/23/issues.pdf", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'pdf'
                 should_route :get, "/projects/23/issues.atom", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'atom'
                 should_route :get, "/projects/23/issues.xml", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'xml'
                 should_route :get, "/issues/64", :controller => 'issues', :action => 'show', :id => '64'
                 should_route :get, "/issues/64.pdf", :controller => 'issues', :action => 'show', :id => '64', :format => 'pdf'
                 should_route :get, "/issues/64.atom", :controller => 'issues', :action => 'show', :id => '64', :format => 'atom'
                 should_route :get, "/issues/64.xml", :controller => 'issues', :action => 'show', :id => '64', :format => 'xml'
                 should_route :get, "/projects/23/issues/new", :controller => 'issues', :action => 'new', :project_id => '23'
+                should_route :post, "/issues.xml", :controller => 'issues', :action => 'new', :format => 'xml'
                 should_route :get, "/issues/64/edit", :controller => 'issues', :action => 'edit', :id => '64'
                 # TODO: Should use PUT
                 should_route :post, "/issues/64/edit", :controller => 'issues', :action => 'edit', :id => '64'
+                should_route :put, "/issues/1.xml", :controller => 'issues', :action => 'update', :id => '1', :format => 'xml'
                 # TODO: Should use DELETE
                 should_route :post, "/issues/64/destroy", :controller => 'issues', :action => 'destroy', :id => '64'
+                should_route :delete, "/issues/1.xml", :controller => 'issues', :action => 'destroy', :id => '1', :format => 'xml'
                 # Extra actions
                 should_route :get, "/projects/23/issues/64/copy", :controller => 'issues', :action => 'new', :project_id => '23', :copy_from => '64'
                 should_route :get, "/issues/1/move", :controller => 'issues', :action => 'move', :id => '1'
                 should_route :post, "/issues/1/move", :controller => 'issues', :action => 'move', :id => '1'
                 should_route :post, "/issues/1/quoted", :controller => 'issues', :action => 'reply', :id => '1'
                 should_route :get, "/issues/calendar", :controller => 'issues', :action => 'calendar'
                 should_route :post, "/issues/calendar", :controller => 'issues', :action => 'calendar'
                 should_route :get, "/projects/project-name/issues/calendar", :controller => 'issues', :action => 'calendar', :project_id => 'project-name'
                 should_route :post, "/projects/project-name/issues/calendar", :controller => 'issues', :action => 'calendar', :project_id => 'project-name'
                 should_route :get, "/issues/gantt", :controller => 'issues', :action => 'gantt'
                 should_route :post, "/issues/gantt", :controller => 'issues', :action => 'gantt'
                 should_route :get, "/projects/project-name/issues/gantt", :controller => 'issues', :action => 'gantt', :project_id => 'project-name'
                 should_route :post, "/projects/project-name/issues/gantt", :controller => 'issues', :action => 'gantt', :project_id => 'project-name'
                 should_route :get, "/issues/auto_complete", :controller => 'issues', :action => 'auto_complete'
               end
+              context "issue categories" do
+                should_route :get, "/projects/test/issue_categories/new", :controller => 'issue_categories', :action => 'new', :project_id => 'test'
+                should_route :post, "/projects/test/issue_categories/new", :controller => 'issue_categories', :action => 'new', :project_id => 'test'
+              end
+              context "issue relations" do
+                should_route :post, "/issues/1/relations", :controller => 'issue_relations', :action => 'new', :issue_id => '1'
+                should_route :post, "/issues/1/relations/23/destroy", :controller => 'issue_relations', :action => 'destroy', :issue_id => '1', :id => '23'
+              end
               context "issue reports" do
                 should_route :get, "/projects/567/issues/report", :controller => 'reports', :action => 'issue_report', :id => '567'
                 should_route :get, "/projects/567/issues/report/assigned_to", :controller => 'reports', :action => 'issue_report_details', :id => '567', :detail => 'assigned_to'
               end
+              context "members" do
+                should_route :post, "/projects/5234/members/new", :controller => 'members', :action => 'new', :id => '5234'
+              end
+              context "messages" do
+                should_route :get, "/boards/22/topics/2", :controller => 'messages', :action => 'show', :id => '2', :board_id => '22'
+                should_route :get, "/boards/lala/topics/new", :controller => 'messages', :action => 'new', :board_id => 'lala'
+                should_route :get, "/boards/lala/topics/22/edit", :controller => 'messages', :action => 'edit', :id => '22', :board_id => 'lala'
+                should_route :post, "/boards/lala/topics/new", :controller => 'messages', :action => 'new', :board_id => 'lala'
+                should_route :post, "/boards/lala/topics/22/edit", :controller => 'messages', :action => 'edit', :id => '22', :board_id => 'lala'
+                should_route :post, "/boards/22/topics/555/replies", :controller => 'messages', :action => 'reply', :id => '555', :board_id => '22'
+                should_route :post, "/boards/22/topics/555/destroy", :controller => 'messages', :action => 'destroy', :id => '555', :board_id => '22'
+              end
+              context "news" do
+                should_route :get, "/news", :controller => 'news', :action => 'index'
+                should_route :get, "/news.atom", :controller => 'news', :action => 'index', :format => 'atom'
+                should_route :get, "/news.xml", :controller => 'news', :action => 'index', :format => 'xml'
+                should_route :get, "/news.json", :controller => 'news', :action => 'index', :format => 'json'
+                should_route :get, "/projects/567/news", :controller => 'news', :action => 'index', :project_id => '567'
+                should_route :get, "/projects/567/news.atom", :controller => 'news', :action => 'index', :format => 'atom', :project_id => '567'
+                should_route :get, "/projects/567/news.xml", :controller => 'news', :action => 'index', :format => 'xml', :project_id => '567'
+                should_route :get, "/projects/567/news.json", :controller => 'news', :action => 'index', :format => 'json', :project_id => '567'
+                should_route :get, "/news/2", :controller => 'news', :action => 'show', :id => '2'
+                should_route :get, "/projects/567/news/new", :controller => 'news', :action => 'new', :project_id => '567'
+                should_route :get, "/news/234", :controller => 'news', :action => 'show', :id => '234'
+                should_route :post, "/projects/567/news/new", :controller => 'news', :action => 'new', :project_id => '567'
+                should_route :post, "/news/567/edit", :controller => 'news', :action => 'edit', :id => '567'
+                should_route :post, "/news/567/destroy", :controller => 'news', :action => 'destroy', :id => '567'
+              end
+              context "projects" do
+                should_route :get, "/projects", :controller => 'projects', :action => 'index'
+                should_route :get, "/projects.atom", :controller => 'projects', :action => 'index', :format => 'atom'
+                should_route :get, "/projects.xml", :controller => 'projects', :action => 'index', :format => 'xml'
+                should_route :get, "/projects/new", :controller => 'projects', :action => 'add'
+                should_route :get, "/projects/test", :controller => 'projects', :action => 'show', :id => 'test'
+                should_route :get, "/projects/1.xml", :controller => 'projects', :action => 'show', :id => '1', :format => 'xml'
+                should_route :get, "/projects/4223/settings", :controller => 'projects', :action => 'settings', :id => '4223'
+                should_route :get, "/projects/4223/settings/members", :controller => 'projects', :action => 'settings', :id => '4223', :tab => 'members'
+                should_route :get, "/projects/567/destroy", :controller => 'projects', :action => 'destroy', :id => '567'
+                should_route :get, "/projects/33/files", :controller => 'projects', :action => 'list_files', :id => '33'
+                should_route :get, "/projects/33/files/new", :controller => 'projects', :action => 'add_file', :id => '33'
+                should_route :get, "/projects/33/roadmap", :controller => 'projects', :action => 'roadmap', :id => '33'
+                should_route :get, "/projects/33/activity", :controller => 'projects', :action => 'activity', :id => '33'
+                should_route :get, "/projects/33/activity.atom", :controller => 'projects', :action => 'activity', :id => '33', :format => 'atom'
+                should_route :post, "/projects/new", :controller => 'projects', :action => 'add'
+                should_route :post, "/projects.xml", :controller => 'projects', :action => 'add', :format => 'xml'
+                should_route :post, "/projects/4223/edit", :controller => 'projects', :action => 'edit', :id => '4223'
+                should_route :post, "/projects/64/destroy", :controller => 'projects', :action => 'destroy', :id => '64'
+                should_route :post, "/projects/33/files/new", :controller => 'projects', :action => 'add_file', :id => '33'
+                should_route :post, "/projects/64/archive", :controller => 'projects', :action => 'archive', :id => '64'
+                should_route :post, "/projects/64/unarchive", :controller => 'projects', :action => 'unarchive', :id => '64'
+                should_route :post, "/projects/64/activities/save", :controller => 'projects', :action => 'save_activities', :id => '64'
+                should_route :put, "/projects/1.xml", :controller => 'projects', :action => 'edit', :id => '1', :format => 'xml'
+                should_route :delete, "/projects/1.xml", :controller => 'projects', :action => 'destroy', :id => '1', :format => 'xml'
+                should_route :delete, "/projects/64/reset_activities", :controller => 'projects', :action => 'reset_activities', :id => '64'
+              end
+              context "repositories" do
+                should_route :get, "/projects/redmine/repository", :controller => 'repositories', :action => 'show', :id => 'redmine'
+                should_route :get, "/projects/redmine/repository/edit", :controller => 'repositories', :action => 'edit', :id => 'redmine'
+                should_route :get, "/projects/redmine/repository/revisions", :controller => 'repositories', :action => 'revisions', :id => 'redmine'
+                should_route :get, "/projects/redmine/repository/revisions.atom", :controller => 'repositories', :action => 'revisions', :id => 'redmine', :format => 'atom'
+                should_route :get, "/projects/redmine/repository/revisions/2457", :controller => 'repositories', :action => 'revision', :id => 'redmine', :rev => '2457'
+                should_route :get, "/projects/redmine/repository/revisions/2457/diff", :controller => 'repositories', :action => 'diff', :id => 'redmine', :rev => '2457'
+                should_route :get, "/projects/redmine/repository/revisions/2457/diff.diff", :controller => 'repositories', :action => 'diff', :id => 'redmine', :rev => '2457', :format => 'diff'
+                should_route :get, "/projects/redmine/repository/diff/path/to/file.c", :controller => 'repositories', :action => 'diff', :id => 'redmine', :path => %w[path to file.c]
+                should_route :get, "/projects/redmine/repository/revisions/2/diff/path/to/file.c", :controller => 'repositories', :action => 'diff', :id => 'redmine', :path => %w[path to file.c], :rev => '2'
+                should_route :get, "/projects/redmine/repository/browse/path/to/file.c", :controller => 'repositories', :action => 'browse', :id => 'redmine', :path => %w[path to file.c]
+                should_route :get, "/projects/redmine/repository/entry/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c]
+                should_route :get, "/projects/redmine/repository/revisions/2/entry/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :rev => '2'
+                should_route :get, "/projects/redmine/repository/raw/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :format => 'raw'
+                should_route :get, "/projects/redmine/repository/revisions/2/raw/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :rev => '2', :format => 'raw'
+                should_route :get, "/projects/redmine/repository/annotate/path/to/file.c", :controller => 'repositories', :action => 'annotate', :id => 'redmine', :path => %w[path to file.c]
+                should_route :get, "/projects/redmine/repository/changes/path/to/file.c", :controller => 'repositories', :action => 'changes', :id => 'redmine', :path => %w[path to file.c]
+                should_route :get, "/projects/redmine/repository/statistics", :controller => 'repositories', :action => 'stats', :id => 'redmine'
+                should_route :post, "/projects/redmine/repository/edit", :controller => 'repositories', :action => 'edit', :id => 'redmine'
+              end
+              context "timelogs" do
+                should_route :get, "/issues/567/time_entries/new", :controller => 'timelog', :action => 'edit', :issue_id => '567'
+                should_route :get, "/projects/ecookbook/time_entries/new", :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook'
+                should_route :get, "/projects/ecookbook/issues/567/time_entries/new", :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook', :issue_id => '567'
+                should_route :get, "/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22'
+                should_route :get, "/time_entries/report", :controller => 'timelog', :action => 'report'
+                should_route :get, "/projects/567/time_entries/report", :controller => 'timelog', :action => 'report', :project_id => '567'
+                should_route :get, "/projects/567/time_entries/report.csv", :controller => 'timelog', :action => 'report', :project_id => '567', :format => 'csv'
+                should_route :get, "/time_entries", :controller => 'timelog', :action => 'details'
+                should_route :get, "/time_entries.csv", :controller => 'timelog', :action => 'details', :format => 'csv'
+                should_route :get, "/time_entries.atom", :controller => 'timelog', :action => 'details', :format => 'atom'
+                should_route :get, "/projects/567/time_entries", :controller => 'timelog', :action => 'details', :project_id => '567'
+                should_route :get, "/projects/567/time_entries.csv", :controller => 'timelog', :action => 'details', :project_id => '567', :format => 'csv'
+                should_route :get, "/projects/567/time_entries.atom", :controller => 'timelog', :action => 'details', :project_id => '567', :format => 'atom'
+                should_route :get, "/issues/234/time_entries", :controller => 'timelog', :action => 'details', :issue_id => '234'
+                should_route :get, "/issues/234/time_entries.csv", :controller => 'timelog', :action => 'details', :issue_id => '234', :format => 'csv'
+                should_route :get, "/issues/234/time_entries.atom", :controller => 'timelog', :action => 'details', :issue_id => '234', :format => 'atom'
+                should_route :get, "/projects/ecookbook/issues/123/time_entries", :controller => 'timelog', :action => 'details', :project_id => 'ecookbook', :issue_id => '123'
+                should_route :post, "/time_entries/55/destroy", :controller => 'timelog', :action => 'destroy', :id => '55'
+              end
               context "users" do
                 should_route :get, "/users", :controller => 'users', :action => 'index'
                 should_route :get, "/users/44", :controller => 'users', :action => 'show', :id => '44'
                 should_route :get, "/users/new", :controller => 'users', :action => 'add'
                 should_route :get, "/users/444/edit", :controller => 'users', :action => 'edit', :id => '444'
                 should_route :get, "/users/222/edit/membership", :controller => 'users', :action => 'edit', :id => '222', :tab => 'membership'
                 should_route :post, "/users/new", :controller => 'users', :action => 'add'
                 should_route :post, "/users/444/edit", :controller => 'users', :action => 'edit', :id => '444'
                 should_route :post, "/users/123/memberships", :controller => 'users', :action => 'edit_membership', :id => '123'
                 should_route :post, "/users/123/memberships/55", :controller => 'users', :action => 'edit_membership', :id => '123', :membership_id => '55'
                 should_route :post, "/users/567/memberships/12/destroy", :controller => 'users', :action => 'destroy_membership', :id => '567', :membership_id => '12'
               end
               context "versions" do
                 should_route :get, "/projects/foo/versions/new", :controller => 'versions', :action => 'new', :project_id => 'foo'
                 should_route :post, "/projects/foo/versions/new", :controller => 'versions', :action => 'new', :project_id => 'foo'
               end
-              context "wikis" do
+              context "wiki (singular, project's pages)" do
                 should_route :get, "/projects/567/wiki", :controller => 'wiki', :action => 'index', :id => '567'
                 should_route :get, "/projects/567/wiki/lalala", :controller => 'wiki', :action => 'index', :id => '567', :page => 'lalala'
                 should_route :get, "/projects/567/wiki/my_page/edit", :controller => 'wiki', :action => 'edit', :id => '567', :page => 'my_page'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/history", :controller => 'wiki', :action => 'history', :id => '1', :page => 'CookBook_documentation'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/diff/2/vs/1", :controller => 'wiki', :action => 'diff', :id => '1', :page => 'CookBook_documentation', :version => '2', :version_from => '1'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/annotate/2", :controller => 'wiki', :action => 'annotate', :id => '1', :page => 'CookBook_documentation', :version => '2'
                 should_route :get, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :id => '22', :page => 'ladida'
                 should_route :get, "/projects/567/wiki/page_index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'page_index'
                 should_route :get, "/projects/567/wiki/Page_Index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'Page_Index'
                 should_route :get, "/projects/567/wiki/date_index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'date_index'
                 should_route :get, "/projects/567/wiki/export", :controller => 'wiki', :action => 'special', :id => '567', :page => 'export'
                 should_route :post, "/projects/567/wiki/my_page/edit", :controller => 'wiki', :action => 'edit', :id => '567', :page => 'my_page'
                 should_route :post, "/projects/567/wiki/CookBook_documentation/preview", :controller => 'wiki', :action => 'preview', :id => '567', :page => 'CookBook_documentation'
                 should_route :post, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :id => '22', :page => 'ladida'
                 should_route :post, "/projects/22/wiki/ladida/destroy", :controller => 'wiki', :action => 'destroy', :id => '22', :page => 'ladida'
                 should_route :post, "/projects/22/wiki/ladida/protect", :controller => 'wiki', :action => 'protect', :id => '22', :page => 'ladida'
               end
+              context "wikis (plural, admin setup)" do
+                should_route :get, "/projects/ladida/wiki/destroy", :controller => 'wikis', :action => 'destroy', :id => 'ladida'
+                should_route :post, "/projects/ladida/wiki", :controller => 'wikis', :action => 'edit', :id => 'ladida'
+                should_route :post, "/projects/ladida/wiki/destroy", :controller => 'wikis', :action => 'destroy', :id => 'ladida'
+              end
               context "administration panel" do
                 should_route :get, "/admin/projects", :controller => 'admin', :action => 'projects'
               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