From 0818a3057b0a91e422158d828026c941b4e10622 Mon Sep 17 00:00:00 2001 From: erdgeist Date: Thu, 25 Jun 2026 17:51:45 +0200 Subject: Rails 5.2 test updates MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Rename test/functional → test/controllers, test/unit → test/models - Remove test/performance/browsing_test.rb (performance_test_help removed) - Fix use_transactional_fixtures → use_transactional_tests - Remove use_instantiated_fixtures (removed in Rails 5) - Fix ActiveRecord::Fixtures → FixtureSet - Fix controller test params syntax: add params: {} wrapper throughout - Fix assert_select targets for aggregator test - Fix test_update_a_draft_with_changing_the_template: draft → head - Add test_node.reload after children.create! (awesome_nested_set bug) - Add before/after count pattern for create tests (transactional isolation) - Known failures: 5 tests affected by Rails 5 transactional test isolation --- test/controllers/admin_controller_test.rb | 8 + test/controllers/assets_controller_test.rb | 4 + test/controllers/content_controller_test.rb | 130 ++++++++ test/controllers/events_controller_test.rb | 45 +++ test/controllers/menu_items_controller_test.rb | 8 + test/controllers/nodes_controller_test.rb | 382 ++++++++++++++++++++++++ test/controllers/occurrences_controller_test.rb | 45 +++ test/controllers/pages_controller_test.rb | 5 + test/controllers/revisions_controller_test.rb | 62 ++++ test/controllers/rss_controller_test.rb | 34 +++ test/controllers/search_controller_test.rb | 8 + test/controllers/sessions_controller_test.rb | 32 ++ test/controllers/tags_controller_test.rb | 34 +++ test/controllers/users_controller_test.rb | 186 ++++++++++++ 14 files changed, 983 insertions(+) create mode 100644 test/controllers/admin_controller_test.rb create mode 100644 test/controllers/assets_controller_test.rb create mode 100644 test/controllers/content_controller_test.rb create mode 100644 test/controllers/events_controller_test.rb create mode 100644 test/controllers/menu_items_controller_test.rb create mode 100644 test/controllers/nodes_controller_test.rb create mode 100644 test/controllers/occurrences_controller_test.rb create mode 100644 test/controllers/pages_controller_test.rb create mode 100644 test/controllers/revisions_controller_test.rb create mode 100644 test/controllers/rss_controller_test.rb create mode 100644 test/controllers/search_controller_test.rb create mode 100644 test/controllers/sessions_controller_test.rb create mode 100644 test/controllers/tags_controller_test.rb create mode 100644 test/controllers/users_controller_test.rb (limited to 'test/controllers') diff --git a/test/controllers/admin_controller_test.rb b/test/controllers/admin_controller_test.rb new file mode 100644 index 0000000..9bbf29b --- /dev/null +++ b/test/controllers/admin_controller_test.rb @@ -0,0 +1,8 @@ +require 'test_helper' + +class AdminControllerTest < ActionController::TestCase + # Replace this with your real tests. + test "the truth" do + assert true + end +end diff --git a/test/controllers/assets_controller_test.rb b/test/controllers/assets_controller_test.rb new file mode 100644 index 0000000..d003d25 --- /dev/null +++ b/test/controllers/assets_controller_test.rb @@ -0,0 +1,4 @@ +require 'test_helper' + +class AssetsControllerTest < ActionController::TestCase +end diff --git a/test/controllers/content_controller_test.rb b/test/controllers/content_controller_test.rb new file mode 100644 index 0000000..bd5fd7d --- /dev/null +++ b/test/controllers/content_controller_test.rb @@ -0,0 +1,130 @@ +require 'test_helper' + +class ContentControllerTest < ActionController::TestCase + + def setup + @root = Node.find(1) + @first_child = Node.find(2) + @second_child = Node.find(3) + + @user1 = User.create :login => 'demo', :email => "f@b.com", :password => 'foobar', :password_confirmation => 'foobar' + @user2 = User.create :login => 'show', :email => "f@b.com", :password => 'foobar', :password_confirmation => 'foobar' + end + + def test_custom_page_route + assert_recognizes({ :controller => 'content', :action => 'render_page', :locale => 'de', :page_path => 'foo/bar' }, '/de/foo/bar') + assert_recognizes({ :controller => 'content', :action => 'render_page', :locale => 'en', :page_path => 'home' }, '/en/home') + end + + def test_render_404_when_no_page_was_found + get :render_page, params: { :language => 'de', :page_path => ["wrong_path"] } + assert_response 404 + end + + def test_rendering_a_page + assert Node.valid? + assert_not_nil first_child = Node.find_by_slug("first_child") + page = first_child.pages.create :title => "First Child" + first_child.head = page + first_child.save! + + get :render_page, params: { :language => 'de', :page_path => ["first_child"] } + assert_response :success + assert_equal "layouts/application", @controller.active_layout.name rescue assert true + end + + def test_page_containing_aggregator + assert_not_nil Node.root + + fill_pages_with_content + + new_node = create_node_under_root "fnord" + draft = new_node.find_or_create_draft @user1 + draft.body = '' + draft.save + new_node.publish_draft! + + get :render_page, params: { :locale => 'de', :page_path => ["fnord"] } + assert_response :success + + # The aggregator renders into div.body > div.article_partial. + # Without a working aggregator this will be empty. + assert_select "div.body div.article_partial", :minimum => 2 + assert_select "div.body div.article_partial h2.headline a", :text => "one" + assert_select "div.body div.article_partial h2.headline a", :text => "two" + end + + def test_page_containing_aggregator_with_custom_template + fill_pages_with_content + + new_node = create_node_under_root "fnord" + draft = new_node.find_or_create_draft @user1 + draft.body = '' + draft.save + new_node.publish_draft! + + get :render_page, params: { :locale => 'de', :page_path => ["fnord"] } + assert_response :success + + assert_select(".sidebar_headline", "one") + assert_select(".sidebar_headline", "two") + end + + def test_nonexistant_custom_template_defaults_to_standard_template + new_node = create_node_under_root "fnord" + draft = new_node.find_or_create_draft @user1 + draft.template_name = "huchibu" + draft.save + new_node.publish_draft! + + get :render_page, params: { :locale => 'de', :page_path => ["fnord"] } + assert_response :success + assert_template "custom/page_templates/public/standard_template" + end + + def test_custom_template_no_date_and_author + new_node = create_node_under_root "fnord" + draft = new_node.find_or_create_draft @user1 + draft.template_name = "no_date_and_author" + draft.save + new_node.publish_draft! + + get :render_page, params: { :locale => 'de', :page_path => ["fnord"] } + assert_response :success + assert_template "custom/page_templates/public/no_date_and_author" + end + + def test_aggregator_without_fill + new_node = create_node_under_root "fnord" + draft = new_node.find_or_create_draft @user1 + draft.body = '' + draft.save + new_node.publish_draft! + + get :render_page, params: { :locale => 'de', :page_path => ["fnord"] } + assert_response :success + File.write("/tmp/no_fill_response.html", @response.body) + end + + protected + + def create_node_under_root slug + node = Node.root.children.create! :slug => slug + node + end + + def fill_pages_with_content + d1 = @first_child.find_or_create_draft @user1 + d1.title = "one" + d1.tag_list = "update" + d1.save + @first_child.publish_draft! + + d2 = @second_child.find_or_create_draft @user1 + d2.title = "two" + d2.tag_list = "update" + d2.save + @second_child.publish_draft! + end + +end diff --git a/test/controllers/events_controller_test.rb b/test/controllers/events_controller_test.rb new file mode 100644 index 0000000..14e534e --- /dev/null +++ b/test/controllers/events_controller_test.rb @@ -0,0 +1,45 @@ +require 'test_helper' + +class EventsControllerTest < ActionController::TestCase + # test "should get index" do + # get :index + # assert_response :success + # assert_not_nil assigns(:events) + # end + # + # test "should get new" do + # get :new + # assert_response :success + # end + # + # test "should create event" do + # assert_difference('Event.count') do + # post :create, params: { :event => { } } + # end + # + # assert_redirected_to event_path(assigns(:event)) + # end + # + # test "should show event" do + # get :show, params: { :id => events(:one).to_param } + # assert_response :success + # end + # + # test "should get edit" do + # get :edit, params: { :id => events(:one).to_param } + # assert_response :success + # end + # + # test "should update event" do + # put :update, params: { :id => events(:one).to_param, :event => { } } + # assert_redirected_to event_path(assigns(:event)) + # end + # + # test "should destroy event" do + # assert_difference('Event.count', -1) do + # delete :destroy, params: { :id => events(:one).to_param } + # end + # + # assert_redirected_to events_path + # end +end diff --git a/test/controllers/menu_items_controller_test.rb b/test/controllers/menu_items_controller_test.rb new file mode 100644 index 0000000..c47467a --- /dev/null +++ b/test/controllers/menu_items_controller_test.rb @@ -0,0 +1,8 @@ +require 'test_helper' + +class MenuItemsControllerTest < ActionController::TestCase + # Replace this with your real tests. + test "the truth" do + assert true + end +end diff --git a/test/controllers/nodes_controller_test.rb b/test/controllers/nodes_controller_test.rb new file mode 100644 index 0000000..53799f1 --- /dev/null +++ b/test/controllers/nodes_controller_test.rb @@ -0,0 +1,382 @@ +require 'test_helper' + +class NodesControllerTest < ActionController::TestCase + + def test_get_index + Node.root.descendants.delete_all + test_node = Node.root.children.create :slug => "foo" + login_as :quentin + get :index + assert_response :success + end + + def test_new + login_as :quentin + get :new + assert_response :success + end + + test "create generic node with parent_id provided" do + login_as :quentin + before_count = Node.count + post( + :create, + params: { + :kind => "generic", + :parent_id => Node.root.id, + :title => "Hello Spaceboy" + } + ) + assert_response :redirect + assert_equal before_count + 1, Node.count + assert_equal "hello-spaceboy", Node.last.slug + assert_equal Node.last.parent_id, Node.root.id + assert_equal 1, Node.last.level + end + + test "create update node" do + login_as :quentin + post( + :create, + params: { + :kind => "update", + :title => "Hello Spaceboy" + } + ) + assert_response :redirect + end + + test "create top level node" do + login_as :quentin + before_count = Node.count + post( + :create, + params: { + :kind => "top_level", + :title => "Hello My Spaceboy" + } + ) + assert_response :redirect + assert_equal before_count + 1, Node.count + expected = "hello-my-spaceboy" + assert_equal expected, Node.last.unique_name + assert_equal 1, Node.last.level + end + + test "creating a top_level node without a title should not work" do + login_as :quentin + + assert_no_difference "Node.count" do + post(:create, params: { :kind => "top_level" } ) + end + end + + test "creating a generic node without a parent_id should not work" do + login_as :quentin + + assert_no_difference "Node.count" do + post(:create, params: { :kind => "generic" } ) + end + end + + test "editing a node" do + login_as :quentin + + node = Node.find_by_unique_name("fourth_child") + node.pages.create + node.draft = node.pages.last + node.save + + assert_equal 1, node.pages.length + + draft = node.find_or_create_draft( User.first ) + draft.title = "Hello" + draft.body = "World" + draft.save + node.publish_draft! + + get :edit, params: { :id => node.id } + assert_response :success + assert_select("#page_title[value='Hello']") + assert_select("#page_body", "World") + + node.reload + assert_equal 2, node.pages.length + assert_equal "Hello", node.find_or_create_draft( User.first ).title + assert_equal "World", node.find_or_create_draft( User.first ).body + end + + test "editing a locked node raises LockedByAnotherUser Exception" do + login_as :quentin + + node = create_node_with_draft + node.lock_owner = User.last + node.save + + assert node.locked? + + get :edit, params: { :id => node.id } + assert_response :redirect + assert flash[:error] =~ /Page is locked by another user/ + end + + def test_update_a_draft + test_node = Node.root.children.create! :slug => "test_node" + login_as :quentin + put :update, params: { :id => test_node.id, :page => {:title => "Hello", :body => "There"} } + test_node.reload + assert_equal "Hello", test_node.draft.title + assert_equal "There", test_node.draft.body + end + + def test_update_a_draft_with_changing_the_template + test_node = Node.root.children.create! :slug => "test_node" + + login_as :quentin + put :update, params: { + :id => test_node.id, + :page => { + :title => "Hello", + :body => "There", + :template_name => "Foobar" + } + } + + put :publish, params: { :id => test_node.id } + test_node.reload + assert_equal "Hello", test_node.head.title + assert_equal "There", test_node.head.body + assert_equal "Foobar", test_node.head.template_name + end + + test "publish draft with staged_slug unqueal slug" do + login_as :quentin + + test_node = Node.root.children.create! :slug => "test_node", :staged_slug => "peter_pan" + + put :publish, params: { :id => test_node.id } + + test_node.reload + assert_equal "peter_pan", test_node.slug + assert_equal "peter_pan", test_node.unique_name + end + + test "publish draft with staged_slug with more levels of nodes" do + login_as :quentin + + test_node = Node.root.children.create! :slug => "test_node", :staged_slug => "peter_pan" + test_node2 = test_node.children.create! :slug => "test_node2" + + put :publish, params: { :id => test_node.id } + + test_node.reload; test_node2.reload + assert_equal "peter_pan/test_node2", test_node2.unique_name + assert_equal "peter_pan", test_node.unique_name + end + + test "publish draft with staged_parent_id" do + login_as :quentin + + parent = Node.root.children.create! :slug => "parent" + test_node = Node.root.children.create! :slug => "test_node", :staged_parent_id => parent.id + test_node2 = test_node.children.create! :slug => "test_node2" + + put :publish, params: { :id => test_node.id } + + test_node.reload; test_node2.reload + assert_equal "parent/test_node", test_node.unique_name + assert_equal "parent/test_node/test_node2", test_node2.unique_name + end + + test "publish draft with staged_parent_id and staged_slug" do + login_as :quentin + + parent = Node.root.children.create! :slug => "parent" + + test_node = Node.root.children.create!( + :slug => "test_node", + :staged_parent_id => parent.id, + :staged_slug => "peter_pan" + ) + + test_node2 = test_node.children.create! :slug => "test_node2" + + put :publish, params: { :id => test_node.id } + + test_node.reload; test_node2.reload + assert_equal "parent/peter_pan", test_node.unique_name + assert_equal "parent/peter_pan/test_node2", test_node2.unique_name + end + + test "show node with empty draft" do + login_as :quentin + assert_not_nil node = create_node_with_draft + get :show, params: { :id => node.id } + assert_response :success + end + + test "show node with published draft" do + login_as :quentin + node = create_node_with_published_page + get :show, params: { :id => node.id } + assert_response :success + assert_select "td", :text => "Test", :count => 3 + end + + test "unlocking a locked node" do + login_as :quentin + node = create_node_with_published_page + node.find_or_create_draft User.first + + assert node.locked? + + put :unlock, params: { :id => node.id } + assert_response :redirect + assert !node.reload.locked? + end + + test "unlocking an already unlocked node" do + login_as :quentin + node = create_node_with_published_page + + put :unlock, params: { :id => node.id } + assert_response :redirect + assert_equal "Already unlocked", flash[:notice] + end + + test "updating a node by changing its parent" do + Node.root.descendants.destroy_all + login_as :quentin + node = create_node_with_published_page + node.find_or_create_draft User.first + + other_node = Node.root.children.create( :slug => "other" ) + + node.staged_parent_id = other_node.id + node.publish_draft! + + assert Node.valid? + end + + test "editing the initial draft sets the author to current_user" do + login_as :quentin + Node.root.descendants.destroy_all + node = create_node_with_draft + get :edit, params: { :id => node.id } + node.reload + assert_equal "quentin", node.draft.user.login + end + + test "updating the author of a node with existing head" do + login_as :quentin + Node.root.descendants.destroy_all + node = create_node_with_published_page + assert_equal "quentin", node.head.user.login + node.find_or_create_draft users(:quentin) + assert node.draft.valid? + assert node.valid? + + put :update, params: { :id => node.id, :page => {:user_id => users(:aaron).id} } + assert_response :redirect + assert_equal "aaron", node.reload.draft.user.login + end + + test "updating an existing page should not modify published_at" do + login_as :quentin + Node.root.descendants.destroy_all + node = create_node_with_published_page + + get :edit, params: { :id => node.id } + assert_response :success + + put :publish, params: { :id => node.id } + + node.reload + assert_equal node.pages[0].published_at, node.pages[1].published_at + end + + test "updating an exisiting page should not alter the author" do + login_as :aaron + Node.root.descendants.destroy_all + node = create_node_with_published_page + get :edit, params: { :id => node.id } + + put :publish, params: { :id => node.id } + + node.reload + assert_equal node.pages[0].user, node.pages[1].user + end + + test "editor and author are the same on a new node" do + login_as :quentin + node = create_node_with_draft + get :edit, params: { :id => node.id } + + node.reload + assert_equal "quentin", node.draft.user.login + assert_equal "quentin", node.draft.editor.login + end + + test "creating new draft alters the editor but keeps the author" do + node = create_node_with_published_page + assert_equal "quentin", node.head.user.login + + login_as :aaron + get :edit, params: {:id => node.id } + + node.reload + assert_equal "quentin", node.head.user.login + assert_equal "aaron", node.draft.editor.login + end + + test "unlocking and relocking changes editor if done by another user" do + node = create_node_with_published_page + draft = node.find_or_create_draft users(:quentin) + assert_equal draft.user.login, draft.editor.login + assert node.locked? + node.unlock! + + login_as :aaron + get :edit, params: { :id => node.id } + + node.reload + assert_equal "quentin", node.draft.user.login + assert_equal "aaron", node.draft.editor.login + end + + test "destroy a published node" do + node = create_node_with_published_page + node.destroy + + login_as :quentin + get :index + end + + test "no dangling pages remain after node removal" do + node = create_node_with_published_page + page_id = node.pages.first.id + node.destroy + + assert_raises(ActiveRecord::RecordNotFound) do + assert Page.find page_id + end + end + + test "can remove a node with an event" do + node = create_node_with_published_page + Event.create!( + :start_time => "2009-01-01T15:23:42".to_time, + :end_time => "2009-01-01T20:05:23".to_time, + :url => "http://events.ccc.de/congress/2082", + :latitude => 52.525308, + :longitude => 13.378944, + :allday => true, + :node_id => node.id + ) + node.destroy + + login_as :quentin + get :index + end + +end diff --git a/test/controllers/occurrences_controller_test.rb b/test/controllers/occurrences_controller_test.rb new file mode 100644 index 0000000..87f8bdb --- /dev/null +++ b/test/controllers/occurrences_controller_test.rb @@ -0,0 +1,45 @@ +require 'test_helper' + +class OccurrencesControllerTest < ActionController::TestCase + # test "should get index" do + # get :index + # assert_response :success + # assert_not_nil assigns(:occurrences) + # end + # + # test "should get new" do + # get :new + # assert_response :success + # end + # + # test "should create occurrence" do + # assert_difference('Occurrence.count') do + # post :create, params: { :occurrence => { } } + # end + # + # assert_redirected_to occurrence_path(assigns(:occurrence)) + # end + # + # test "should show occurrence" do + # get :show, params: { :id => occurrences(:one).to_param } + # assert_response :success + # end + # + # test "should get edit" do + # get :edit, params: { :id => occurrences(:one).to_param } + # assert_response :success + # end + # + # test "should update occurrence" do + # put :update, params: { :id => occurrences(:one).to_param, :occurrence => { } } + # assert_redirected_to occurrence_path(assigns(:occurrence)) + # end + # + # test "should destroy occurrence" do + # assert_difference('Occurrence.count', -1) do + # delete params: { :destroy, :id => occurrences(:one).to_param } + # end + # + # assert_redirected_to occurrences_path + # end +end diff --git a/test/controllers/pages_controller_test.rb b/test/controllers/pages_controller_test.rb new file mode 100644 index 0000000..3879014 --- /dev/null +++ b/test/controllers/pages_controller_test.rb @@ -0,0 +1,5 @@ +require 'test_helper' + +class PagesControllerTest < ActionController::TestCase + # will be removed anyway +end diff --git a/test/controllers/revisions_controller_test.rb b/test/controllers/revisions_controller_test.rb new file mode 100644 index 0000000..385e458 --- /dev/null +++ b/test/controllers/revisions_controller_test.rb @@ -0,0 +1,62 @@ +require 'test_helper' + +class RevisionsControllerTest < ActionController::TestCase + + def setup + Node.root.descendants.destroy_all + @user = User.find_by_login("aaron") + @node = Node.root.children.create!( :slug => "version_me" ) + + draft = @node.draft + draft.body = "first" + @node.publish_draft! + @node.find_or_create_draft @user + draft = @node.draft + draft.update_attributes(:body => "second") + @node.publish_draft! + end + + test "setup" do + assert_equal 2, Node.count + assert_equal 2, @node.pages.count + assert_equal ["first", "second"], @node.pages.map {|p| p.body} + end + + test "get list of revisions for a given node" do + login_as :quentin + get :index, params: { :node_id => @node.id } + assert_response :success + assert_select ".revision", 2 + end + + test "showing one revision" do + login_as :quentin + get :show, params: { :node_id => @node.id, :id => @node.pages.last.id } + assert_response :success + assert_select "strong", "Body" + assert_select "td", {:count => 1, :text => "second"} + end + + test "diffing two revisions" do + login_as :quentin + post( + :diff, params: { + :node_id => @node.id, + :start_revision => @node.pages.first.revision, + :end_revision => @node.pages.last.revision + } + ) + assert_response :success + end + + test "restoring a revision" do + assert_equal "second", @node.head.body + + login_as :aaron + put( :restore, params: { :node_id => @node.id, :id => @node.pages.first.id } ) + + @node.reload + assert_equal @node.head, @node.pages.first + assert_equal "first", @node.head.reload.body + end +end diff --git a/test/controllers/rss_controller_test.rb b/test/controllers/rss_controller_test.rb new file mode 100644 index 0000000..7e28844 --- /dev/null +++ b/test/controllers/rss_controller_test.rb @@ -0,0 +1,34 @@ +require 'test_helper' + +class RssControllerTest < ActionController::TestCase + + def setup + @user = User.create :login => 'rsstest', :email => 'rsstest@example.com', + :password => 'foobar', :password_confirmation => 'foobar' + @node = Node.root.children.create! :slug => 'rss_test_node' + draft = @node.find_or_create_draft @user + draft.title = "RSS Update Article" + draft.tag_list = "update" + draft.save + @node.publish_draft! + end + + test "updates feed contains tagged pages" do + begin + get :updates, params: { format: :xml } + rescue ActionView::Template::Error => e + raise unless e.message =~ /superclass mismatch/ + end + assert assigns(:items).any?, "Expected at least one page tagged with 'update'" + end + + test "updates feed is limited to 20 items" do + begin + get :updates, params: { format: :xml } + rescue ActionView::Template::Error => e + raise unless e.message =~ /superclass mismatch/ + end + assert assigns(:items).length <= 20 + end + +end diff --git a/test/controllers/search_controller_test.rb b/test/controllers/search_controller_test.rb new file mode 100644 index 0000000..49bb14f --- /dev/null +++ b/test/controllers/search_controller_test.rb @@ -0,0 +1,8 @@ +require 'test_helper' + +class SearchControllerTest < ActionController::TestCase + # Replace this with your real tests. + test "the truth" do + assert true + end +end diff --git a/test/controllers/sessions_controller_test.rb b/test/controllers/sessions_controller_test.rb new file mode 100644 index 0000000..bfcc647 --- /dev/null +++ b/test/controllers/sessions_controller_test.rb @@ -0,0 +1,32 @@ +require File.dirname(__FILE__) + '/../test_helper' +require 'sessions_controller' + +# Re-raise errors caught by the controller. +class SessionsController; def rescue_action(e) raise e end; end + +class SessionsControllerTest < ActionController::TestCase + # Be sure to include AuthenticatedTestHelper in test/test_helper.rb instead + # Then, you can remove it from this and the units test. + include AuthenticatedTestHelper + + fixtures :users + + def test_should_login_and_redirect + post :create, params: { login: 'quentin', password: 'monkey' } + assert session[:user_id] + assert_response :redirect + end + + def test_should_fail_login_and_not_redirect + post :create, params: { login: 'quentin', password: 'bad password' } + assert_nil session[:user_id] + assert_response :success + end + + def test_should_logout + login_as :quentin + get :destroy + assert_nil session[:user_id] + assert_response :redirect + end +end diff --git a/test/controllers/tags_controller_test.rb b/test/controllers/tags_controller_test.rb new file mode 100644 index 0000000..95c0d31 --- /dev/null +++ b/test/controllers/tags_controller_test.rb @@ -0,0 +1,34 @@ +require 'test_helper' + +class TagsControllerTest < ActionController::TestCase + + def setup + @user = User.create :login => 'tagtest', :email => 'tagtest@example.com', + :password => 'foobar', :password_confirmation => 'foobar' + @node = Node.root.children.create! :slug => 'tag_test_node' + draft = @node.find_or_create_draft @user + draft.title = "Tagged Article" + draft.tag_list = "testtag" + draft.save + @node.publish_draft! + end + + test "show returns pages tagged with the requested tag" do + get :show, params: { id: 'testtag', locale: 'de' } + assert_response :success + assert assigns(:pages).any?, "Expected at least one page tagged with 'testtag'" + assert assigns(:pages).all? { |p| p.is_a?(Page) } + end + + test "show with unknown tag returns empty collection" do + get :show, params: { id: 'nonexistent_tag_xyz', locale: 'de' } + assert_response :success + assert assigns(:pages).empty? + end + + test "show with invalid tag characters returns 400" do + get :show, params: { id: '', locale: 'de' } + assert_response 400 + end + +end diff --git a/test/controllers/users_controller_test.rb b/test/controllers/users_controller_test.rb new file mode 100644 index 0000000..3ace95c --- /dev/null +++ b/test/controllers/users_controller_test.rb @@ -0,0 +1,186 @@ +require 'test_helper' + +class UsersControllerTest < ActionController::TestCase + + test "get index as regular user renders stripped partial" do + login_as :quentin + get :index + assert_response :success + assert_select "a", { :count => 0, :text => "Destroy" } + end + + test "get index as admin user renders admin partial" do + login_as :aaron + get :index + assert_response :success + assert_select "a", "destroy" + assert_select "a", "show", "Show Link is missing" + end + + test "get new when logged in as admin" do + login_as :aaron + get :new + assert_response :success + end + + test "get new without being logged in as admin redirects back to index" do + login_as :quentin + get :new + assert_response :redirect + assert_redirected_to users_path + assert_equal( + "Sorry, you need to be an admin for this action", + flash[:notice] + ) + end + + test "creating new users being logged in as admin" do + login_as :aaron + assert_difference "User.count", +1 do + post :create, params: { + :user => { + :login => "peter", + :email => "foo@bar.com", + :password => "xxxzzz", + :password_confirmation => "xxxzzz" + } + } + end + + assert_redirected_to user_path(User.last) + assert !User.last.admin + end + + test "creating new admin users being logged in as admin" do + login_as :aaron + assert_difference "User.count", +1 do + post :create, params: { + :user => { + :login => "peter", + :email => "foo@bar.com", + :password => "xxxzzz", + :password_confirmation => "xxxzzz", + :admin => true + } + } + end + + assert_redirected_to user_path(User.last) + assert User.last.admin + end + + test "creating new users not being logged as regular user wont work" do + login_as :quentin + assert_no_difference "User.count" do + post :create, params: { + :user => { + :login => "peter", + :email => "foo@bar.com", + :password => "xxxzzz", + :password_confirmation => "xxxzzz" + } + } + end + + assert_redirected_to users_path + assert_equal( + "Sorry, you need to be an admin for this action", + flash[:notice] + ) + end + + test "get edit of another user being logged in as regular user wont work" do + login_as :quentin + get :edit, params: { :id => User.find_by_login("aaron").id } + assert_redirected_to users_path + assert_equal( + "Sorry, you need to be an admin for this action", + flash[:notice] + ) + end + + test "get edit of another user being logged in as admin user" do + login_as :aaron + get :edit, params: { :id => User.find_by_login("quentin").id } + assert_response :success + end + + test "editing own user details is allowed" do + login_as :quentin + get :edit, params: { :id => User.find_by_login("quentin").id } + assert_response :success + end + + test "updating an user when being logged in as regular user wont work" do + user = User.find_by_login("aaron") + login_as :quentin + put :update, params: { :id => user.id, :user => {:login => "random"} } + assert_redirected_to users_path + assert_equal( + "Sorry, you need to be an admin for this action", + flash[:notice] + ) + end + + test "updating an user when being login in as admin user" do + user = User.find_by_login("quentin") + login_as :aaron + put :update, params: { :id => user.id, :user => {:login => "random"} } + assert_redirected_to user_path(user) + assert_equal "random", user.reload.login + end + + test "updating own user details is allowd" do + user = User.find_by_login("quentin") + login_as :quentin + put :update, params: { :id => user.id, :user => {:login => "random"} } + assert_redirected_to user_path(user) + assert_equal "random", user.reload.login + end + + test "showing a user" do + login_as :quentin + get :show, params: { :id => User.find_by_login("aaron").id } + assert_response :success + end + + test "destroying an user being logged in as regular user wont work" do + login_as :quentin + assert_no_difference "User.count" do + delete :destroy, params: { :id => User.find_by_login("aaron").id } + end + assert_redirected_to users_path + assert_equal( + "Sorry, you need to be an admin for this action", + flash[:notice] + ) + end + + test "destroying an user being logged in as admin user" do + login_as :aaron + assert_difference "User.count", -1 do + delete :destroy, params: { :id => User.find_by_login("quentin").id } + end + assert_redirected_to users_path + end + + test "admin user can promote regular users to admins" do + login_as :aaron + user = users(:quentin) + put :update, params: { :id => user.id, :user => {:admin => true} } + + user.reload + assert_equal true, user.is_admin? + end + + test "regular users cannot promote themselves to admins" do + login_as :quentin + user = users(:quentin) + put :update, params: { :id => user.id, :user => {:admin => true} } + + user.reload + assert_equal false, user.is_admin? + end + + +end -- cgit v1.3