jro_apps/redmine Commit - r15342:29ddc82a11f3

Removes calls to #assert_template and #assigns in functional tests....

Jean-Philippe Lang -

r15342:29ddc82a11f3

parent child

Context file:

r15342:29ddc82a11f3

Collapse all files

test/fixtures/wiki_content_versions.yml +6 -5

                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v1
+                 Line from v1
                  Some [[documentation]] here...
              wiki_content_versions_002:
                updated_on: 2007-03-07 00:08:34 +01:00
                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v2
+                 Line from v1
                  Some updated [[documentation]] here...
              wiki_content_versions_003:
                updated_on: 2007-03-07 00:10:51 +01:00
                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v3
                  Some updated [[documentation]] here...
              wiki_content_versions_004:
                data: |-

test/functional/boards_controller_test.rb +3 -4

                    post :create, :project_id => 1, :board => { :name => '', :description => 'Testing board creation'}
                  end
                  assert_response :success
-                 assert_template 'new'
+                 assert_select_error /Name cannot be blank/
                end
                def test_edit
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => 2
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'input[name=?][value=?]', 'board[name]', 'Discussion'
                end
                def test_edit_with_parent
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => board.id
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'select[name=?]', 'board[parent_id]' do
                    assert_select 'option[value="2"][selected=selected]'
                  @request.session[:user_id] = 2
                  put :update, :project_id => 1, :id => 2, :board => { :name => '', :description => 'Testing board update'}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /Name cannot be blank/
                end
                def test_destroy

test/functional/roles_controller_test.rb +11 -19

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:roles)
-                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
+                 assert_select 'table.roles tbody' do
+                   assert_select 'tr', Role.count
                  assert_select 'a[href="/roles/1/edit"]', :text => 'Manager'
                end
+               end
                def test_new
                  get :new
                  assert_response :success
-                 assert_template 'new'
+                 assert_select 'input[name=?]', 'role[name]'
                end
                def test_new_with_copy
                  get :new, :params => {:copy => copy_from.id.to_s}
                  assert_response :success
-                 assert_template 'new'
-                 role = assigns(:role)
-                 assert_equal copy_from.permissions, role.permissions
+                 assert_select 'input[name=?]', 'role[name]'
                  assert_select 'form' do
                    # blank name
                    }
                  }
                  assert_response :success
-                 assert_template 'new'
-                 assert_select 'div#errorExplanation'
+                 assert_select_error /Name cannot be blank/
                end
                def test_create_without_workflow_copy
                def test_edit
                  get :edit, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'edit'
-                 assert_equal Role.find(1), assigns(:role)
+                 assert_select 'input[name=?][value=?]', 'role[name]', 'Manager'
                  assert_select 'select[name=?]', 'role[issues_visibility]'
                end
                def test_edit_anonymous
                  get :edit, :params => {:id => Role.anonymous.id}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'input[name=?]', 'role[name]', 0
                  assert_select 'select[name=?]', 'role[issues_visibility]', 0
                end
                def test_update_with_failure
                  put :update, :params => {:id => 1, :role => {:name => ''}}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /Name cannot be blank/
                end
                def test_destroy
                def test_get_permissions
                  get :permissions
                  assert_response :success
-                 assert_template 'permissions'
-                 assert_not_nil assigns(:roles)
-                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
                  assert_select 'input[name=?][type=checkbox][value=add_issues][checked=checked]', 'permissions[3][]'
                  assert_select 'input[name=?][type=checkbox][value=delete_issues]:not([checked])', 'permissions[3][]'

test/functional/search_controller_test.rb +137 -81

                  User.current = nil
                end
-               def test_search_for_projects
+               def test_search_without_q_should_display_search_form
                  get :index
                  assert_response :success
-                 assert_template 'index'
+                 assert_select '#content input[name=q]'
+               end
+               def test_search_for_projects
                  get :index, :params => {:q => "cook"}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).include?(Project.find(1))
+                 assert_select '#search-results dt.project a', :text => /eCookbook/
                end
                def test_search_on_archived_project_should_return_404
                    get :index, :params => {:q => 'recipe subproject commit', :all_words => ''}
                  end
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).include?(Issue.find(2))
-                 assert assigns(:results).include?(Issue.find(5))
-                 assert assigns(:results).include?(Changeset.find(101))
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => /Feature request #2/
+                   assert_select 'dt.issue a', :text => /Bug #5/
+                   assert_select 'dt.changeset a', :text => /Revision 1/
                  assert_select 'dt.issue a', :text => /Add ingredients categories/
                  assert_select 'dd', :text => /should be classified by categories/
+                 end
-                 assert assigns(:result_count_by_type).is_a?(Hash)
-                 assert_equal 5, assigns(:result_count_by_type)['changesets']
+                 assert_select '#search-results-counts' do
                  assert_select 'a', :text => 'Changesets (5)'
                end
+               end
                def test_search_issues
                  get :index, :params => {:q => 'issue', :issues => 1}
                  assert_response :success
-                 assert_template 'index'
-                 assert_equal true, assigns(:all_words)
-                 assert_equal false, assigns(:titles_only)
-                 assert assigns(:results).include?(Issue.find(8))
-                 assert assigns(:results).include?(Issue.find(5))
-                 assert_select 'dt.issue.closed a',  :text => /Closed/
+                 assert_select 'input[name=all_words][checked=checked]'
+                 assert_select 'input[name=titles_only]:not([checked])'
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => /Bug #5/
+                   assert_select 'dt.issue.closed a', :text => /Bug #8 \(Closed\)/
+                 end
                end
                def test_search_issues_should_search_notes
                  get :index, :params => {:q => 'searchkeyword', :issues => 1}
                  assert_response :success
-                 assert_include Issue.find(2), assigns(:results)
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => /Feature request #2/
+                 end
                end
                def test_search_issues_with_multiple_matches_in_journals_should_return_issue_once
                  get :index, :params => {:q => 'searchkeyword', :issues => 1}
                  assert_response :success
-                 assert_include Issue.find(2), assigns(:results)
-                 assert_equal 1, assigns(:results).size
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => /Feature request #2/
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_issues_should_search_private_notes_with_permission_only
                  Role.find(1).add_permission! :view_private_notes
                  get :index, :params => {:q => 'searchkeyword', :issues => 1}
                  assert_response :success
-                 assert_include Issue.find(2), assigns(:results)
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => /Feature request #2/
+                 end
                  Role.find(1).remove_permission! :view_private_notes
                  get :index, :params => {:q => 'searchkeyword', :issues => 1}
                  assert_response :success
-                 assert_not_include Issue.find(2), assigns(:results)
+                 assert_select '#search-results' do
+                   assert_select 'dt', :text => /Feature request #2/, :count => 0
+                 end
                end
                def test_search_all_projects_with_scope_param
                  get :index, :params => {:q => 'issue', :scope => 'all'}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).present?
+                 assert_select '#search-results dt'
                end
                def test_search_my_projects
                  @request.session[:user_id] = 2
                  get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).include?(Issue.find(1))
-                 assert !assigns(:results).include?(Issue.find(5))
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => /Bug #1/
+                   assert_select 'dt', :text => /Bug #5/, :count => 0
+                 end
                end
                def test_search_my_projects_without_memberships
                  # anonymous user has no memberships
                  get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).empty?
+                 assert_select '#search-results' do
+                   assert_select 'dt', 0
+                 end
                end
                def test_search_project_and_subprojects
                  get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'subprojects', :all_words => ''}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:results).include?(Issue.find(1))
-                 assert assigns(:results).include?(Issue.find(5))
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => /Bug #1/
+                   assert_select 'dt.issue', :text => /Bug #5/
+                 end
                end
                def test_search_without_searchable_custom_fields
-                 CustomField.update_all "searchable = #{ActiveRecord::Base.connection.quoted_false}"
+                 CustomField.update_all :searchable => false
                  get :index, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:project)
                  get :index, :params => {:id => 1, :q => "can"}
                  assert_response :success
-                 assert_template 'index'
                end
                def test_search_with_searchable_custom_fields
                  get :index, :params => {:id => 1, :q => "stringforcustomfield"}
                  assert_response :success
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 1, results.size
-                 assert results.include?(Issue.find(7))
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => /#7/
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_without_attachments
                  attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => '0'}
-                 results = assigns(:results)
-                 assert_equal 1, results.size
-                 assert_equal issue, results.first
+                 assert_response :success
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => /##{issue.id}/
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_attachments_only
                  attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => 'only'}
-                 results = assigns(:results)
-                 assert_equal 1, results.size
-                 assert_equal attachment.container, results.first
+                 assert_response :success
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => / #1 /
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_with_attachments
-                 Issue.generate! :subject => 'search_attachments'
+                 issue = Issue.generate! :subject => 'search_attachments'
                  Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => '1'}
-                 results = assigns(:results)
-                 assert_equal 2, results.size
+                 assert_response :success
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => / #1 /
+                   assert_select 'dt.issue', :text => / ##{issue.id} /
+                   assert_select 'dt', 2
+                 end
                end
                def test_search_open_issues
                  Issue.generate! :subject => 'search_open', :status_id => 5
                  get :index, :params => {:id => 1, :q => 'search_open', :open_issues => '1'}
-                 results = assigns(:results)
-                 assert_equal 1, results.size
+                 assert_response :success
+                 assert_select '#search-results' do
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_all_words
                  # 'all words' is on by default
                  get :index, :params => {:id => 1, :q => 'recipe updating saving', :all_words => '1'}
-                 assert_equal true, assigns(:all_words)
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 1, results.size
-                 assert results.include?(Issue.find(3))
+                 assert_response :success
+                 assert_select 'input[name=all_words][checked=checked]'
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => / #3 /
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_one_of_the_words
                  get :index, :params => {:id => 1, :q => 'recipe updating saving', :all_words => ''}
-                 assert_equal false, assigns(:all_words)
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 3, results.size
-                 assert results.include?(Issue.find(3))
+                 assert_response :success
+                 assert_select 'input[name=all_words]:not([checked])'
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => / #3 /
+                   assert_select 'dt', 3
+                 end
                end
                def test_search_titles_only_without_result
                  get :index, :params => {:id => 1, :q => 'recipe updating saving', :titles_only => '1'}
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 0, results.size
+                 assert_response :success
+                 assert_select 'input[name=titles_only][checked=checked]'
+                 assert_select '#search-results' do
+                   assert_select 'dt', 0
+                 end
                end
                def test_search_titles_only
                  get :index, :params => {:id => 1, :q => 'recipe', :titles_only => '1'}
-                 assert_equal true, assigns(:titles_only)
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 2, results.size
+                 assert_response :success
+                 assert_select 'input[name=titles_only][checked=checked]'
+                 assert_select '#search-results' do
+                   assert_select 'dt', 2
+                 end
                end
                def test_search_content
                  Issue.where(:id => 1).update_all("description = 'This is a searchkeywordinthecontent'")
                  get :index, :params => {:id => 1, :q => 'searchkeywordinthecontent', :titles_only => ''}
-                 assert_equal false, assigns(:titles_only)
-                 results = assigns(:results)
-                 assert_not_nil results
-                 assert_equal 1, results.size
+                 assert_response :success
+                 assert_select 'input[name=titles_only]:not([checked])'
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue', :text => / #1 /
+                   assert_select 'dt', 1
+                 end
                end
                def test_search_with_pagination
-                 issue = (0..24).map {Issue.generate! :subject => 'search_with_limited_results'}.reverse
+                 issues = (0..24).map {Issue.generate! :subject => 'search_with_limited_results'}.reverse
                  get :index, :params => {:q => 'search_with_limited_results'}
                  assert_response :success
-                 assert_equal issue[0..9], assigns(:results)
+                 issues[0..9].each do |issue|
+                   assert_select '#search-results dt.issue', :text => / ##{issue.id} /
+                 end
                  get :index, :params => {:q => 'search_with_limited_results', :page => 2}
                  assert_response :success
-                 assert_equal issue[10..19], assigns(:results)
+                 issues[10..19].each do |issue|
+                   assert_select '#search-results dt.issue', :text => / ##{issue.id} /
+                 end
                  get :index, :params => {:q => 'search_with_limited_results', :page => 3}
                  assert_response :success
-                 assert_equal issue[20..24], assigns(:results)
+                 issues[20..24].each do |issue|
+                   assert_select '#search-results dt.issue', :text => / ##{issue.id} /
+                 end
                  get :index, :params => {:q => 'search_with_limited_results', :page => 4}
                  assert_response :success
-                 assert_equal [], assigns(:results)
+                 assert_select '#search-results dt', 0
                end
                def test_search_with_invalid_project_id
                  get :index, :params => {:id => 195, :q => 'recipe'}
                  assert_response 404
-                 assert_nil assigns(:results)
                end
                def test_quick_jump_to_issue
                  # issue of a private project
                  get :index, :params => {:q => "4"}
                  assert_response :success
-                 assert_template 'index'
                end
                def test_large_integer
                  get :index, :params => {:q => '4615713488'}
                  assert_response :success
-                 assert_template 'index'
                end
                def test_tokens_with_quotes
-                 get :index, :params => {:id => 1, :q => '"good bye" hello "bye bye"'}
-                 assert_equal ["good bye", "hello", "bye bye"], assigns(:tokens)
+                 issue1 = Issue.generate! :subject => 'say hello'
+                 issue2 = Issue.generate! :subject => 'say good bye'
+                 issue3 = Issue.generate! :subject => 'say goodbye'
+                 get :index, :params => {:q => '"good bye" hello "bye bye"', :all_words => ''}
+                 assert_response :success
+                 assert_select '#search-results' do
+                   assert_select 'dt.issue a', :text => / ##{issue1.id} /
+                   assert_select 'dt.issue a', :text => / ##{issue2.id} /
+                   assert_select 'dt.issue a', :text => / ##{issue3.id} /, :count => 0
+                 end
                end
                def test_results_should_be_escaped_once

test/functional/search_custom_fields_visibility_test.rb +2 -2

                      assert_response :success
                      # we should get a result only if the custom field is visible
                      if fields.include?(field)
-                       assert_equal 1, assigns(:results).size
+                       assert_select '#search-results dt', 1
                      else
-                       assert_equal 0, assigns(:results).size
+                       assert_select '#search-results dt', 0
                      end
                    end
                  end

test/functional/settings_controller_test.rb +3 -3

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'input[name=?][value=?]', 'settings[app_title]', Setting.app_title
                end
                def test_get_edit
                  get :edit
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'input[name=?][value=""]', 'settings[enabled_scm][]'
                end
                  get :plugin, :params => {:id => 'foo'}
                  assert_response :success
-                 assert_template 'plugin'
                  assert_select 'form[action="/settings/plugin/foo"]' do
                    assert_select 'input[name=?][value=?]', 'settings[sample_setting]', 'Plugin setting value'
                  end

test/functional/time_entry_reports_controller_test.rb +11 -29

                def test_report_at_project_level
                  get :report, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'report'
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries/report'
                end
                def test_report_all_projects
                  get :report
                  assert_response :success
-                 assert_template 'report'
                  assert_select 'form#query_form[action=?]', '/time_entries/report'
                end
                def test_report_all_projects_one_criteria
                  get :report, :params => {:columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "8.65", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '8.65'
                end
                def test_report_all_time
                  get :report, :params => {:project_id => 1, :criteria => ['project', 'issue']}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '162.90'
                end
                def test_report_all_time_by_day
                  get :report, :params => {:project_id => 1, :criteria => ['project', 'issue'], :columns => 'day'}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '162.90'
                  assert_select 'th', :text => '2007-03-12'
                end
                def test_report_one_criteria
                  get :report, :params => {:project_id => 1, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "8.65", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '8.65'
                end
                def test_report_two_criteria
                  get :report, :params => {:project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criteria => ["user", "activity"]}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '162.90'
                end
                def test_report_custom_field_criteria_with_multiple_values_on_single_value_custom_field_should_not_fail
                def test_report_one_day
                  get :report, :params => {:project_id => 1, :columns => 'day', :from => "2007-03-23", :to => "2007-03-23", :criteria => ["user", "activity"]}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "4.25", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '4.25'
                end
                def test_report_by_week_should_use_commercial_year
                def test_report_should_propose_association_custom_fields
                  get :report
                  assert_response :success
-                 assert_template 'report'
                  assert_select 'select[name=?]', 'criteria[]' do
                    assert_select 'option[value=cf_1]', {:text => 'Database'}, 'Issue custom field not found'
                def test_report_with_association_custom_fields
                  get :report, :params => {:criteria => ['cf_1', 'cf_3', 'cf_7']}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal 3, assigns(:report).criteria.size
-                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
+                 assert_select 'tr.total td:last', :text => '162.90'
                  # Custom fields columns
                  assert_select 'th', :text => 'Database'
                def test_report_one_criteria_no_result
                  get :report, :params => {:project_id => 1, :columns => 'week', :from => "1998-04-01", :to => "1998-04-30", :criteria => ['project']}
                  assert_response :success
-                 assert_template 'report'
-                 assert_not_nil assigns(:report)
-                 assert_equal "0.00", "%.2f" % assigns(:report).total_hours
+                 assert_select '.nodata'
                end
                def test_report_status_criterion
                  get :report, :params => {:project_id => 1, :criteria => ['status']}
                  assert_response :success
-                 assert_template 'report'
                  assert_select 'th', :text => 'Status'
                  assert_select 'td', :text => 'New'
                end

test/functional/timelog_controller_test.rb +37 -44

                  @request.session[:user_id] = 3
                  get :new
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id', 0
                  assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                  assert_select 'select[name=?]', 'time_entry[project_id]' do
                  @request.session[:user_id] = 3
                  get :new, :params => {:project_id => 1}
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id'
                  assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                  assert_select 'select[name=?]', 'time_entry[project_id]', 0
                  @request.session[:user_id] = 3
                  get :new, :params => {:issue_id => 2}
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id', 0
                  assert_select 'input[name=?][type=hidden]', 'issue_id'
                  assert_select 'select[name=?]', 'time_entry[project_id]', 0
                  @request.session[:user_id] = 3
                  get :new, :params => {:time_entry => {:project_id => '1'}}
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'select[name=?]', 'time_entry[project_id]' do
                    assert_select 'option[value="1"][selected=selected]'
                  end
                  @request.session[:user_id] = 2
                  get :edit, :params => {:id => 2, :project_id => nil}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'form[action=?]', '/time_entries/2'
                end
                  @request.session[:user_id] = 1
                  get :edit, :params => {:project_id => 1, :id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  # Blank option since nothing is pre-selected
                  assert_select 'option', :text => '--- Please select ---'
                end
                  post :create, :params => {:time_entry => {:issue_id => ''}}
                  assert_response :success
-                 assert_template 'new'
+                 assert_select_error /Project cannot be blank/
                end
                def test_create_with_failure
                    }
                  }
                  assert_response :success
-                 assert_template 'new'
                end
                def test_create_without_project
                  end
                  assert_response :success
-                 assert assigns(:time_entry).errors[:issue_id].present?
+                 assert_select_error /Issue is invalid/
                end
                def test_create_without_project_should_deny_without_permission
                      :issue_id => '5'
                    }
                  }
-                 assert_response 200
-                 assert_include "Issue is invalid", assigns(:time_entry).errors.full_messages
+                 assert_response :success
+                 assert_select_error /Issue is invalid/
                end
                def test_get_bulk_edit
                  get :bulk_edit, :params => {:ids => [1, 2]}
                  assert_response :success
-                 assert_template 'bulk_edit'
                  assert_select 'ul#bulk-selection' do
                    assert_select 'li', 2
                  get :bulk_edit, :params => {:ids => [1, 2, 6]}
                  assert_response :success
-                 assert_template 'bulk_edit'
                end
                def test_bulk_edit_with_edit_own_time_entries_permission
                  @request.session[:user_id] = 2
                  get :index
                  assert_response :success
-                 assert_template 'index'
                  assert_select 'a[href=?]', '/time_entries/new', :text => /Log time/
                end
                def test_index_my_spent_time
                  @request.session[:user_id] = 2
-                 get :index, :params => {:user_id => 'me'}
+                 get :index, :params => {:user_id => 'me', :c => ['user']}
                  assert_response :success
-                 assert_template 'index'
-                 assert assigns(:entries).all? {|entry| entry.user_id == 2}
+                 users = css_select('table.time-entries tbody td.user').map(&:text).uniq
+                 assert_equal ["John Smith"], users
                end
                def test_index_at_project_level
-                 get :index, :params => {:project_id => 'ecookbook'}
+                 get :index, :params => {:project_id => 'ecookbook', :c => ['project']}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:entries)
-                 assert_equal 4, assigns(:entries).size
+                 assert_select 'tr.time-entry', 4
                  # project and subproject
-                 assert_equal [1, 3], assigns(:entries).collect(&:project_id).uniq.sort
+                 projects = css_select('table.time-entries tbody td.project').map(&:text).uniq.sort
+                 assert_equal ["eCookbook", "eCookbook Subproject 1"], projects
                  assert_select '.total-for-hours', :text => 'Hours: 162.90'
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                  entry = TimeEntry.generate!(:project => Project.find(3))
                  with_settings :display_subprojects_issues => '0' do
-                   get :index, :params => {:project_id => 'ecookbook'}
+                   get :index, :params => {:project_id => 'ecookbook', :c => ['project']}
                    assert_response :success
-                   assert_template 'index'
-                   assert_not_include entry, assigns(:entries)
+                   projects = css_select('table.time-entries tbody td.project').map(&:text).uniq.sort
+                   assert_equal ["eCookbook"], projects
                  end
                end
                  entry = TimeEntry.generate!(:project => Project.find(3))
                  with_settings :display_subprojects_issues => '0' do
-                   get :index, :params => {:project_id => 'ecookbook', :subproject_id => 3}
+                   get :index, :params => {:project_id => 'ecookbook', :c => ['project'], :subproject_id => 3}
                    assert_response :success
-                   assert_template 'index'
-                   assert_include entry, assigns(:entries)
+                   projects = css_select('table.time-entries tbody td.project').map(&:text).uniq.sort
+                   assert_equal ["eCookbook", "eCookbook Subproject 1"], projects
                  end
                end
                    :v => {'spent_on' => ['2007-03-20', '2007-04-30']}
                  }
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:entries)
-                 assert_equal 3, assigns(:entries).size
+                 assert_select 'tr.time-entry', 3
                  assert_select '.total-for-hours', :text => 'Hours: 12.90'
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                    :to => '2007-04-30'
                  }
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:entries)
-                 assert_equal 3, assigns(:entries).size
+                 assert_select 'tr.time-entry', 3
                  assert_select '.total-for-hours', :text => 'Hours: 12.90'
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                    :v => {'spent_on' => ['2012-06-15', '2012-06-16']}
                  }
                  assert_response :success
-                 assert_equal [t2, t1, t3], assigns(:entries)
+                 assert_equal [t2, t1, t3].map(&:id).map(&:to_s), css_select('input[name="ids[]"]').map {|e| e.attr('value')}
                  get :index, :params => {
                    :project_id => 1,
                    :sort => 'spent_on'
                  }
                  assert_response :success
-                 assert_equal [t3, t1, t2], assigns(:entries)
+                 assert_equal [t3, t1, t2].map(&:id).map(&:to_s), css_select('input[name="ids[]"]').map {|e| e.attr('value')}
                end
                def test_index_with_filter_on_issue_custom_field
                    :v => {'issue.cf_2' => ['filter_on_issue_custom_field']}
                  }
                  assert_response :success
-                 assert_equal [entry], assigns(:entries)
+                 assert_equal [entry].map(&:id).map(&:to_s), css_select('input[name="ids[]"]').map {|e| e.attr('value')}
                end
                def test_index_with_issue_custom_field_column
                    :c => %w(project spent_on issue comments hours issue.cf_2)
                  }
                  assert_response :success
-                 assert_include :'issue.cf_2', assigns(:query).column_names
                  assert_select 'td.issue_cf_2', :text => 'filter_on_issue_custom_field'
                end
                    :c => ["hours", field_name]
                  }
                  assert_response :success
-                 assert_include field_name.to_sym, assigns(:query).column_names
                  assert_select "td.#{field_name}", :text => 'CF Value'
                end
                    :sort => field_name
                  }
                  assert_response :success
-                 assert_include field_name.to_sym, assigns(:query).column_names
                  assert_select "th a.sort", :text => 'String Field'
                  # Make sure that values are properly sorted
-                 values = assigns(:entries).map {|e| e.custom_field_value(field)}.compact
-                 assert_equal 3, values.size
+                 values = css_select("td.#{field_name}").map(&:text).reject(&:blank?)
                  assert_equal values.sort, values
+                 assert_equal 3, values.size
                end
                def test_index_with_query
                  get :index, :params => {: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)
+                 assert_select 'entry > title', :text => /7\.65 hours/
                end
                def test_index_at_project_level_should_include_csv_export_dialog

test/functional/timelog_custom_fields_visibility_test.rb +4 -2

                  assert_select 'td', :text => 'ValueB', :count => 0
                  assert_select 'td', {:text => 'ValueC'}, "ValueC not found in:\n#{response.body}"
-                 get :index, :params => {:set_filter => '1', "issue.cf_#{@field2.id}" => '*'}
-                 assert_equal %w(ValueA ValueC), assigns(:entries).map{|i| i.issue.custom_field_value(@field2)}.sort
+                 get :index, :params => {:set_filter => '1', "issue.cf_#{@field2.id}" => '*', :c => ["issue.cf_#{@field2.id}"]}
+                 assert_select 'td', :text => "ValueA"
+                 assert_select 'td', :text => "ValueC"
+                 assert_select 'td', :text => "ValueB", :count => 0
                end
              end

test/functional/trackers_controller_test.rb +3 -7

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
+                 assert_select 'table.trackers'
                end
                def test_index_by_anonymous_should_redirect_to_login_form
                def test_new
                  get :new
                  assert_response :success
-                 assert_template 'new'
+                 assert_select 'input[name=?]', 'tracker[name]'
                end
                def test_create
                    }
                  end
                  assert_response :success
-                 assert_template 'new'
                  assert_select_error /name cannot be blank/i
                end
                  get :edit, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'input[name=?][value="1"][checked=checked]', 'tracker[project_ids][]'
                  assert_select 'input[name=?][value="2"]:not([checked])', 'tracker[project_ids][]'
                  get :edit, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'input[name=?][value=assigned_to_id][checked=checked]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=fixed_version_id][checked=checked]', 'tracker[core_fields][]'
                def test_update_with_failure
                  put :update, :params => {:id => 1, :tracker => { :name => '' }}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select_error /name cannot be blank/i
                end
                def test_get_fields
                  get :fields
                  assert_response :success
-                 assert_template 'fields'
                  assert_select 'form' do
                    assert_select 'input[type=checkbox][name=?][value=assigned_to_id]', 'trackers[1][core_fields][]'

test/functional/users_controller_test.rb +26 -35

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:users)
-                 # active users only
-                 assert_nil assigns(:users).detect {|u| !u.active?}
+                 assert_select 'table.users'
+                 assert_select 'tr.user.active'
+                 assert_select 'tr.user.locked', 0
                end
                def test_index_with_status_filter
                  get :index, :params => {:status => 3}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:users)
-                 assert_equal [3], assigns(:users).map(&:status).uniq
+                 assert_select 'tr.user.active', 0
+                 assert_select 'tr.user.locked'
                end
                def test_index_with_name_filter
                  get :index, :params => {:name => 'john'}
                  assert_response :success
-                 assert_template 'index'
-                 users = assigns(:users)
-                 assert_not_nil users
-                 assert_equal 1, users.size
-                 assert_equal 'John', users.first.firstname
+                 assert_select 'tr.user td.username', :text => 'jsmith'
+                 assert_select 'tr.user', 1
                end
                def test_index_with_group_filter
                  get :index, :params => {:group_id => '10'}
                  assert_response :success
-                 assert_template 'index'
-                 users = assigns(:users)
-                 assert users.any?
-                 assert_equal([], (users - Group.find(10).users))
+                 assert_select 'tr.user', Group.find(10).users.count
                  assert_select 'select[name=group_id]' do
                    assert_select 'option[value="10"][selected=selected]'
                  end
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'show'
-                 assert_not_nil assigns(:user)
+                 assert_select 'h2', :text => /John Smith/
+               end
+               def test_show_should_display_visible_custom_fields
+                 @request.session[:user_id] = nil
+                 UserCustomField.find_by_name('Phone number').update_attribute :visible, true
+                 get :show, :params => {:id => 2}
+                 assert_response :success
                  assert_select 'li', :text => /Phone number/
                end
                  UserCustomField.find_by_name('Phone number').update_attribute :visible, false
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'show'
-                 assert_not_nil assigns(:user)
                  assert_select 'li', :text => /Phone number/, :count => 0
                end
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 5}
                  assert_response 200
-                 assert_not_nil assigns(:user)
+                 assert_select 'h2', :text => /Dave2 Lopper2/
                end
                def test_show_user_who_is_not_visible_should_return_404
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 memberships = assigns(:memberships)
-                 assert_not_nil memberships
-                 project_ids = memberships.map(&:project_id)
-                 assert project_ids.include?(2) #private project admin can see
+                 # membership of private project admin can see
+                 assert_select 'li a', :text => "OnlineStore"
                end
                def test_show_current_should_require_authentication
                  @request.session[:user_id] = 2
                  get :show, :params => {:id => 'current'}
                  assert_response :success
-                 assert_template 'show'
-                 assert_equal User.find(2), assigns(:user)
+                 assert_select 'h2', :text => /John Smith/
                end
                def test_new
                  get :new
                  assert_response :success
-                 assert_template :new
-                 assert assigns(:user)
+                 assert_select 'input[name=?]', 'user[login]'
                end
                def test_create
                    post :create, :params => {:user => {}}
                  end
                  assert_response :success
-                 assert_template 'new'
+                 assert_select_error /Email cannot be blank/
                end
                def test_create_with_failure_sould_preserve_preference
                    }
                  end
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'select#pref_time_zone option[selected=selected]', :text => /Paris/
                  assert_select 'input#pref_no_self_notified[value="1"][checked=checked]'
                def test_edit
                  get :edit, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'edit'
-                 assert_equal User.find(2), assigns(:user)
+                 assert_select 'input[name=?][value=?]', 'user[login]', 'jsmith'
                end
                def test_edit_registered_user
                    }
                  end
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /First name cannot be blank/
                end
                def test_update_with_group_ids_should_assign_groups
                def test_update_notified_project
                  get :edit, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'edit'
                  u = User.find(2)
                  assert_equal [1, 2, 5], u.projects.collect{|p| p.id}.sort
                  assert_equal [1, 2, 5], u.notified_projects_ids.sort

test/functional/versions_controller_test.rb +20 -27

                def test_index
                  get :index, :params => {:project_id => 1}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:versions)
                  # Version with no date set appears
-                 assert assigns(:versions).include?(Version.find(3))
+                 assert_select 'h3', :text => Version.find(3).name
                  # Completed version doesn't appear
-                 assert !assigns(:versions).include?(Version.find(1))
+                 assert_select 'h3', :text => Version.find(1).name, :count => 0
                  # Context menu on issues
                  assert_select "script", :text => Regexp.new(Regexp.escape("contextMenuInit('/issues/context_menu')"))
                  assert_select "div#sidebar" do
                def test_index_with_completed_versions
                  get :index, :params => {:project_id => 1, :completed => 1}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:versions)
                  # Version with no date set appears
-                 assert assigns(:versions).include?(Version.find(3))
+                 assert_select 'h3', :text => Version.find(3).name
                  # Completed version appears
-                 assert assigns(:versions).include?(Version.find(1))
+                 assert_select 'h3', :text => Version.find(1).name
                end
                def test_index_with_tracker_ids
+                 (1..3).each do |tracker_id|
+                   Issue.generate! :project_id => 1, :fixed_version_id => 3, :tracker_id => tracker_id
+                 end
                  get :index, :params => {:project_id => 1, :tracker_ids => [1, 3]}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:issues_by_version)
-                 assert_nil assigns(:issues_by_version).values.flatten.detect {|issue| issue.tracker_id == 2}
+                 assert_select 'a.issue.tracker-1'
+                 assert_select 'a.issue.tracker-2', 0
+                 assert_select 'a.issue.tracker-3'
                end
                def test_index_showing_subprojects_versions
                  @subproject_version = Version.create!(:project => Project.find(3), :name => "Subproject version")
                  get :index, :params => {:project_id => 1, :with_subprojects => 1}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:versions)
-                 assert assigns(:versions).include?(Version.find(4)), "Shared version not found"
-                 assert assigns(:versions).include?(@subproject_version), "Subproject version not found"
+                 # Shared version
+                 assert_select 'h3', :text => Version.find(4).name
+                 # Subproject version
+                 assert_select 'h3', :text => /Subproject version/
                end
                def test_index_should_prepend_shared_versions
                def test_show
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'show'
-                 assert_not_nil assigns(:version)
                  assert_select 'h2', :text => /1.0/
                end
                  @request.session[:user_id] = 2
                  get :new, :params => {:project_id => '1'}
                  assert_response :success
-                 assert_template 'new'
+                 assert_select 'input[name=?]', 'version[name]'
                end
                def test_new_from_issue_form
                  @request.session[:user_id] = 2
                  xhr :get, :new, :params => {:project_id => '1'}
                  assert_response :success
-                 assert_template 'new'
                  assert_equal 'text/javascript', response.content_type
                end
                  assert_equal 1, version.project_id
                  assert_response :success
-                 assert_template 'create'
                  assert_equal 'text/javascript', response.content_type
                  assert_include 'test_add_version_from_issue_form', response.body
                end
                    xhr :post, :create, :params => {:project_id => '1', :version => {:name => ''}}
                  end
                  assert_response :success
-                 assert_template 'new'
                  assert_equal 'text/javascript', response.content_type
                end
                  @request.session[:user_id] = 2
                  get :edit, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'input[name=?][value=?]', 'version[name]', Version.find(2).name
                end
                def test_close_completed
                    }
                  }
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /Name cannot be blank/
                end
                def test_destroy
                def test_issue_status_by
                  xhr :get, :status_by, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'status_by'
-                 assert_template '_issue_counts'
                end
                def test_issue_status_by_status
                  xhr :get, :status_by, :params => {:id => 2, :status_by => 'status'}
                  assert_response :success
-                 assert_template 'status_by'
-                 assert_template '_issue_counts'
                  assert_include 'Assigned', response.body
                  assert_include 'Closed', response.body
                end

test/functional/watchers_controller_test.rb +4 -6

                  @request.session[:user_id] = 2
                  xhr :get, :new, :params => {:project_id => 1}
                  assert_response :success
-                 assert_equal Project.find(1), assigns(:project)
                  assert_match /ajax-modal/, response.body
                end
                  @request.session[:user_id] = 2
                  xhr :get, :new, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_equal Project.find(1), assigns(:project)
                  assert_match /ajax-modal/, response.body
                end
                def test_autocomplete_for_user_should_return_visible_users
                  Role.update_all :users_visibility => 'members_of_visible_projects'
-                 hidden = User.generate!(:lastname => 'autocomplete')
-                 visible = User.generate!(:lastname => 'autocomplete')
+                 hidden = User.generate!(:lastname => 'autocomplete_hidden')
+                 visible = User.generate!(:lastname => 'autocomplete_visible')
                  User.add_to_project(visible, Project.find(1))
                  @request.session[:user_id] = 2
                  xhr :get, :autocomplete_for_user, :params => {:q => 'autocomp', :project_id => 'ecookbook'}
                  assert_response :success
-                 assert_include visible, assigns(:users)
-                 assert_not_include hidden, assigns(:users)
+                 assert_include visible.name, response.body
+                 assert_not_include hidden.name, response.body
                end
                def test_append

test/functional/welcome_controller_test.rb +7 -8

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:news)
+                 assert_select 'h3', :text => 'Latest news'
                end
                def test_browser_language
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  get :index
-                 assert_equal :fr, @controller.current_language
+                 assert_select 'html[lang=fr]'
                end
                def test_browser_language_alternate
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'zh-TW'
                  get :index
-                 assert_equal :"zh-TW", @controller.current_language
+                 assert_select 'html[lang=zh-TW]'
                end
                def test_browser_language_alternate_not_valid
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr-CA'
                  get :index
-                 assert_equal :fr, @controller.current_language
+                 assert_select 'html[lang=fr]'
                end
                def test_browser_language_should_be_ignored_with_force_default_language_for_anonymous
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_anonymous => '1' do
                    get :index
-                   assert_equal :en, @controller.current_language
+                   assert_select 'html[lang=en]'
                  end
                end
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :default_language => 'fi' do
                    get :index
-                   assert_equal :it, @controller.current_language
+                   assert_select 'html[lang=it]'
                  end
                end
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_loggedin => '1', :default_language => 'fi' do
                    get :index
-                   assert_equal :fi, @controller.current_language
+                   assert_select 'html[lang=fi]'
                  end
                end

test/functional/wiki_controller_test.rb +36 -59

                def test_show_start_page
                  get :show, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'show'
-                 assert_select 'h1', :text => /CookBook documentation/
+                 assert_select 'h1', :text => /CookBook documentation/
                  # child_pages macro
                  assert_select 'ul.pages-hierarchy>li>a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image',
                    :text => 'Page with an inline image'
                def test_show_page_with_name
                  get :show, :params => {:project_id => 1, :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'show'
                  assert_select 'h1', :text => /Another page/
                  # Included page with an inline image
                  assert_select 'p', :text => /This is an inline image/
                    get :show, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'}
                  end
                  assert_response :success
-                 assert_template 'show'
                  assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/1', :text => /Previous/
                  assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/diff', :text => /diff/
                  content.save!
                  get :show, :params => {:project_id => 'ecookbook', :id => page.title, :version => '1'}
-                 assert_kind_of WikiContent::Version, assigns(:content)
                  assert_response :success
-                 assert_template 'show'
+                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image', :text => /Current version/
                end
                def test_show_old_version_without_permission_should_be_denied
                    get :show, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'}
                  end
                  assert_response :success
-                 assert_template 'show'
                  assert_select 'a', :text => /Previous/, :count => 0
                  assert_select 'a', :text => /diff/, :count => 0
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :id => 'Unexistent page'}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'textarea[name=?]', 'content[text]'
                end
                def test_show_specific_version_of_an_unexistent_page_without_edit_right
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'select[name=?] option[value="2"][selected=selected]', 'wiki_page[parent_id]'
                end
                  get :show, :params => {:project_id => 1, :id => 'NoContent'}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'textarea[name=?]', 'content[text]'
                end
                  get :new, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'new'
+                 assert_select 'input[name=?]', 'title'
                end
                def test_get_new_xhr
                  xhr :get, :new, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'new'
+                 assert_include 'Unallowed characters', response.body
                end
                def test_post_new_with_valid_title_should_redirect_to_edit
                  post :new, :params => {:project_id => 'ecookbook', :title => 'Another page'}
                  assert_response :success
-                 assert_template 'new'
                  assert_select_error 'Title has already been taken'
                end
                  xhr :post, :new, :params => {:project_id => 'ecookbook', :title => 'Another page'}
                  assert_response :success
-                 assert_template 'new'
                  assert_include 'Title has already been taken', response.body
                end
                  get :edit, :params => {:project_id => 'ecookbook', :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'textarea[name=?]', 'content[text]',
                    :text => WikiPage.find_by_title('Another_page').content.text
                  get :edit, :params => {:project_id => 'ecookbook', :id => 'Page_with_sections', :section => 2}
                  assert_response :success
-                 assert_template 'edit'
                  page = WikiPage.find_by_title('Page_with_sections')
                  section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                    end
                  end
                  assert_response :success
-                 assert_template 'edit'
                  assert_select_error /Comment is too long/
                  assert_select 'textarea#content_text', :text => "edited"
                    end
                  end
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'div.error', :text => /Data has been updated by another user/
                  assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                  assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
                    end
                  end
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'div.error', :text => /Data has been updated by another user/
                  assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                  assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
                    }
                  }
                  assert_response :success
-                 assert_template 'common/_preview'
                  assert_select 'strong', :text => /previewed text/
                end
                    }
                  }
                  assert_response :success
-                 assert_template 'common/_preview'
                  assert_select 'h1', :text => /New page/
                end
                  @request.session[:user_id] = 2
                  get :history, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation'}
                  assert_response :success
-                 assert_template 'history'
-                 assert_not_nil assigns(:versions)
-                 assert_equal 3, assigns(:versions).size
+                 assert_select 'table.wiki-page-versions tbody' do
+                   assert_select 'tr', 3
+                 end
                  assert_select "input[type=submit][name=commit]"
                  assert_select 'td' do
                  @request.session[:user_id] = 2
                  get :history, :params => {:project_id => 'ecookbook', :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'history'
-                 assert_not_nil assigns(:versions)
-                 assert_equal 1, assigns(:versions).size
+                 assert_select 'table.wiki-page-versions tbody' do
+                   assert_select 'tr', 1
+                 end
                  assert_select "input[type=submit][name=commit]", false
                  assert_select 'td' do
                    assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => '1'
                    :version_from => (content.version - 1)
                  }
                  assert_response :success
-                 assert_template 'diff'
                  assert_select 'span.diff_out', :text => 'Line removed'
                  assert_select 'span.diff_in', :text => 'Line added'
                end
                    :version => 2
                  }
                  assert_response :success
-                 assert_template 'annotate'
                  # Line 1
                  assert_select 'table.annotate tr:nth-child(1)' do
                    assert_select 'th.line-num', :text => '1'
+                   assert_select 'td.author', :text => /Redmine Admin/
+                   assert_select 'td', :text => /h1\. CookBook documentation v2/
+                 end
+                 # Line 4
+                 assert_select 'table.annotate tr:nth-child(4)' do
+                   assert_select 'th.line-num', :text => '4'
                    assert_select 'td.author', :text => /John Smith/
-                   assert_select 'td', :text => /h1\. CookBook documentation/
+                   assert_select 'td', :text => /Line from v1/
                  end
                  # Line 5
                  @request.session[:user_id] = 2
                  get :rename, :params => {:project_id => 1, :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'rename'
                  assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                    assert_select 'option[value=""]', :text => ''
                  @request.session[:user_id] = 2
                  get :rename, :params => {:project_id => 1, :id => 'Child_1'}
                  assert_response :success
-                 assert_template 'rename'
                  assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                    assert_select 'option[value=""]', :text => ''
                  get :rename, :params => {:project_id => 1, :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'rename'
                  assert_select 'select[name=?]', 'wiki_page[wiki_id]' do
                    assert_select 'option', 2
                    delete :destroy, :params => {:project_id => 1, :id => 'Another_page'}
                  end
                  assert_response :success
-                 assert_template 'destroy'
                  assert_select 'form' do
                    assert_select 'input[name=todo][value=nullify]'
                    assert_select 'input[name=todo][value=destroy]'
                def test_index
                  get :index, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'index'
-                 pages = assigns(:pages)
-                 assert_not_nil pages
-                 assert_equal Project.find(1).wiki.pages.size, pages.size
-                 assert_equal pages.first.content.updated_on, pages.first.updated_on
+                 assert_select 'ul.pages-hierarchy' do
+                   assert_select 'li', Project.find(1).wiki.pages.count
+                 end
                  assert_select 'ul.pages-hierarchy' do
                    assert_select 'li' do
                  get :export, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_not_nil assigns(:pages)
-                 assert assigns(:pages).any?
                  assert_equal "text/html", @response.content_type
                  assert_select "a[name=?]", "CookBook_documentation"
                  get :export, :params => {:project_id => 'ecookbook', :format => 'pdf'}
                  assert_response :success
-                 assert_not_nil assigns(:pages)
-                 assert assigns(:pages).any?
                  assert_equal 'application/pdf', @response.content_type
                  assert_equal 'attachment; filename="ecookbook.pdf"', @response.headers['Content-Disposition']
                  assert @response.body.starts_with?('%PDF')
                  get :date_index, :params => {:project_id => 'ecookbook'}
                  assert_response :success
-                 assert_template 'date_index'
-                 assert_not_nil assigns(:pages)
-                 assert_not_nil assigns(:pages_by_date)
                  assert_select 'a[href=?]', '/projects/ecookbook/activity.atom?show_wiki_edits=1'
                end
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1}
                  assert_response :success
-                 assert_template 'show'
                  assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit'
                end
                  @request.session[:user_id] = 4
                  get :show, :params => {:project_id => 1}
                  assert_response :success
-                 assert_template 'show'
                  assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit', 0
                end
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :format => 'pdf'}
                  assert_response :success
-                 assert_not_nil assigns(:page)
                  assert_equal 'application/pdf', @response.content_type
                  assert_equal 'attachment; filename="CookBook_documentation.pdf"',
                                @response.headers['Content-Disposition']
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :format => 'html'}
                  assert_response :success
-                 assert_not_nil assigns(:page)
                  assert_equal 'text/html', @response.content_type
                  assert_equal 'attachment; filename="CookBook_documentation.html"',
                                @response.headers['Content-Disposition']
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :format => 'html', :version => 2}
                  assert_response :success
-                 assert_not_nil assigns(:content)
-                 assert_equal 2, assigns(:content).version
                  assert_equal 'text/html', @response.content_type
                  assert_equal 'attachment; filename="CookBook_documentation.html"',
                                @response.headers['Content-Disposition']
-                 assert_select 'h1', :text => /CookBook documentation/
+                 assert_select 'h1', :text => /CookBook documentation v2/
                end
                def test_show_txt
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :format => 'txt'}
                  assert_response :success
-                 assert_not_nil assigns(:page)
                  assert_equal 'text/plain', @response.content_type
                  assert_equal 'attachment; filename="CookBook_documentation.txt"',
                                @response.headers['Content-Disposition']
                  @request.session[:user_id] = 2
                  get :show, :params => {:project_id => 1, :format => 'txt', :version => 2}
                  assert_response :success
-                 assert_not_nil assigns(:content)
-                 assert_equal 2, assigns(:content).version
                  assert_equal 'text/plain', @response.content_type
                  assert_equal 'attachment; filename="CookBook_documentation.txt"',
                                @response.headers['Content-Disposition']
-                 assert_include 'h1. CookBook documentation', @response.body
+                 assert_include 'h1. CookBook documentation v2', @response.body
                end
                def test_edit_unprotected_page
                  @request.session[:user_id] = 4
                  get :edit, :params => {:project_id => 1, :id => 'Another_page'}
                  assert_response :success
-                 assert_template 'edit'
                end
                def test_edit_protected_page_by_nonmember
                  @request.session[:user_id] = 2
                  get :edit, :params => {:project_id => 1, :id => 'CookBook_documentation'}
                  assert_response :success
-                 assert_template 'edit'
                end
                def test_history_of_non_existing_page_should_return_404

test/functional/wikis_controller_test.rb 0 -3

                  assert_difference 'Wiki.count' do
                    xhr :post, :edit, :params => {:id => 3, :wiki => { :start_page => 'Start page' }}
                    assert_response :success
-                   assert_template 'edit'
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_no_difference 'Wiki.count' do
                    xhr :post, :edit, :params => {:id => 3, :wiki => { :start_page => '' }}
                    assert_response :success
-                   assert_template 'edit'
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_no_difference 'Wiki.count' do
                    xhr :post, :edit, :params => {:id => 1, :wiki => { :start_page => 'Other start page' }}
                    assert_response :success
-                   assert_template 'edit'
                    assert_equal 'text/javascript', response.content_type
                  end

test/functional/workflows_controller_test.rb +18 -16

                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
                  count = WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count
                  assert_select 'a[href=?]', '/workflows/edit?role_id=1&tracker_id=2', :content => count.to_s
                def test_get_edit
                  get :edit
                  assert_response :success
-                 assert_template 'edit'
                end
                def test_get_edit_with_role_and_tracker
                  get :edit, :params => {:role_id => 2, :tracker_id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  # used status only
-                 assert_not_nil assigns(:statuses)
-                 assert_equal [2, 3, 5], assigns(:statuses).collect(&:id)
+                 statuses = IssueStatus.where(:id => [2, 3, 5]).sorted.pluck(:name)
+                 assert_equal ["New issue"] + statuses,
+                   css_select('table.workflows.transitions-always tbody tr td:first').map(&:text).map(&:strip)
                  # allowed transitions
                  assert_select 'input[type=checkbox][name=?][value="1"][checked=checked]', 'transitions[3][5][always]'
                def test_get_edit_with_all_roles_and_all_trackers
                  get :edit, :params => {:role_id => 'all', :tracker_id => 'all'}
                  assert_response :success
-                 assert_equal Role.sorted.to_a, assigns(:roles)
-                 assert_equal Tracker.sorted.to_a, assigns(:trackers)
+                 assert_select 'select[name=?][multiple=multiple]', 'role_id[]' do
+                   assert_select 'option[selected=selected]', Role.all.select(&:consider_workflow?).count
+                 end
+                 assert_select 'select[name=?]', 'tracker_id[]' do
+                   assert_select 'option[selected=selected][value=all]'
+                 end
                end
                def test_get_edit_with_role_and_tracker_and_all_statuses
                  get :edit, :params => {:role_id => 2, :tracker_id => 1, :used_statuses_only => '0'}
                  assert_response :success
-                 assert_template 'edit'
-                 assert_not_nil assigns(:statuses)
-                 assert_equal IssueStatus.count, assigns(:statuses).size
+                 statuses = IssueStatus.all.sorted.pluck(:name)
+                 assert_equal ["New issue"] + statuses,
+                   css_select('table.workflows.transitions-always tbody tr td:first').map(&:text).map(&:strip)
                  assert_select 'input[type=checkbox][name=?]', 'transitions[1][1][always]'
                end
                  get :permissions
                  assert_response :success
-                 assert_template 'permissions'
                end
                def test_get_permissions_with_role_and_tracker
                  get :permissions, :params => {:role_id => 1, :tracker_id => 2}
                  assert_response :success
-                 assert_template 'permissions'
                  assert_select 'input[name=?][value="1"]', 'role_id[]'
                  assert_select 'input[name=?][value="2"]', 'tracker_id[]'
                  get :permissions, :params => {:role_id => 1, :tracker_id => 1}
                  assert_response :success
-                 assert_template 'permissions'
                  # Custom field that is always required
                  # The default option is "(Required)"
                  get :permissions, :params => {:role_id => 2, :tracker_id => 1}
                  assert_response :success
-                 assert_template 'permissions'
                  assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf1.id}]"
                  assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf3.id}]"
                  get :permissions, :params => {:role_id => 1, :tracker_id => 2, :used_statuses_only => '0'}
                  assert_response :success
-                 assert_equal IssueStatus.sorted.to_a, assigns(:statuses)
+                 statuses = IssueStatus.all.sorted.pluck(:name)
+                 assert_equal statuses,
+                   css_select('table.workflows.fields_permissions thead tr:nth-child(2) td:not(:first-child)').map(&:text).map(&:strip)
                end
                def test_get_permissions_should_set_css_class
                def test_get_copy
                  get :copy
                  assert_response :success
-                 assert_template 'copy'
                  assert_select 'select[name=source_tracker_id]' do
                    assert_select 'option[value="1"]', :text => 'Bug'
                  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