jro_apps/redmine Commit - r11990:5f747faa58c0

Fixed that viewing/editing a wiki page without WikiContent raises an error (#14986)....

Jean-Philippe Lang -

r11990:5f747faa58c0

parent child

Context file:

r11990:5f747faa58c0

Collapse all files

app/controllers/wiki_controller.rb +10 -11

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             # The WikiController follows the Rails REST controller pattern but with
             # a few differences
             #
             # * index - shows a list of WikiPages grouped by page or date
             # * new - not used
             # * create - not used
             # * show - will also show the form for creating a new wiki page
             # * edit - used to edit an existing or new page
             # * update - used to save a wiki page update to the database, including new pages
             # * destroy - normal
             #
             # Other member and collection methods are also used
             #
             # TODO: still being worked on
             class WikiController < ApplicationController
               default_search_scope :wiki_pages
               before_filter :find_wiki, :authorize
               before_filter :find_existing_or_new_page, :only => [:show, :edit, :update]
               before_filter :find_existing_page, :only => [:rename, :protect, :history, :diff, :annotate, :add_attachment, :destroy, :destroy_version]
               accept_api_auth :index, :show, :update, :destroy
               before_filter :find_attachments, :only => [:preview]
               helper :attachments
               include AttachmentsHelper
               helper :watchers
               include Redmine::Export::PDF
               # List of pages, sorted alphabetically and by parent (hierarchy)
               def index
                 load_pages_for_index
                 respond_to do |format|
                   format.html {
                     @pages_by_parent_id = @pages.group_by(&:parent_id)
                   }
                   format.api
                 end
               end
               # List of page, by last update
               def date_index
                 load_pages_for_index
                 @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}
               end
               # display a page (in editing mode if it doesn't exist)
               def show
-                if @page.new_record?
+                if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
+                  deny_access
+                  return
+                end
+                @content = @page.content_for_version(params[:version])
+                if @content.nil?
                   if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
-                if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
-                  deny_access
-                  return
-                end
-                @content = @page.content_for_version(params[:version])
                 if User.current.allowed_to?(:export_wiki_pages, @project)
                   if params[:format] == 'pdf'
                     send_data(wiki_page_to_pdf(@page, @project), :type => 'application/pdf', :filename => "#{@page.title}.pdf")
                     return
                   elsif params[:format] == 'html'
                     export = render_to_string :action => 'export', :layout => false
                     send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")
                     return
                   elsif params[:format] == 'txt'
                     send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")
                     return
                   end
                 end
                 @editable = editable?
                 @sections_editable = @editable && User.current.allowed_to?(:edit_wiki_pages, @page.project) &&
                   @content.current_version? &&
                   Redmine::WikiFormatting.supports_section_edit?
                 respond_to do |format|
                   format.html
                   format.api
                 end
               end
               # edit an existing page or a new one
               def edit
                 return render_403 unless editable?
                 if @page.new_record?
-                  @page.content = WikiContent.new(:page => @page)
                   if params[:parent].present?
                     @page.parent = @page.wiki.find_page(params[:parent].to_s)
                   end
                 end
                 @content = @page.content_for_version(params[:version])
+                @content ||= WikiContent.new(:page => @page)
                 @content.text = initial_page_content(@page) if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 # To prevent StaleObjectError exception when reverting to a previous version
-                @content.version = @page.content.version
+                @content.version = @page.content.version if @page.content
                 @text = @content.text
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @text, @section_hash = Redmine::WikiFormatting.formatter.new(@text).get_section(@section)
                   render_404 if @text.blank?
                 end
               end
               # Creates a new page or updates an existing one
               def update
                 return render_403 unless editable?
                 was_new_page = @page.new_record?
-                @page.content = WikiContent.new(:page => @page) if @page.new_record?
                 @page.safe_attributes = params[:wiki_page]
-                @content = @page.content
+                @content = @page.content || WikiContent.new(:page => @page)
                 content_params = params[:content]
                 if content_params.nil? && params[:wiki_page].is_a?(Hash)
                   content_params = params[:wiki_page].slice(:text, :comments, :version)
                 end
                 content_params ||= {}
                 @content.comments = content_params[:comments]
                 @text = content_params[:text]
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @section_hash = params[:section_hash]
                   @content.text = Redmine::WikiFormatting.formatter.new(@content.text).update_section(params[:section].to_i, @text, @section_hash)
                 else
                   @content.version = content_params[:version] if content_params[:version]
                   @content.text = @text
                 end
                 @content.author = User.current
-                if @page.save_with_content
+                if @page.save_with_content(@content)
                   attachments = Attachment.attach_files(@page, params[:attachments])
                   render_attachment_warning_if_needed(@page)
                   call_hook(:controller_wiki_edit_after_save, { :params => params, :page => @page})
                   respond_to do |format|
                     format.html { redirect_to project_wiki_page_path(@project, @page.title) }
                     format.api {
                       if was_new_page
                         render :action => 'show', :status => :created, :location => project_wiki_page_path(@project, @page.title)
                       else
                         render_api_ok
                       end
                     }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api { render_validation_errors(@content) }
                   end
                 end
               rescue ActiveRecord::StaleObjectError, Redmine::WikiFormatting::StaleSectionError
                 # Optimistic locking exception
                 respond_to do |format|
                   format.html {
                     flash.now[:error] = l(:notice_locking_conflict)
                     render :action => 'edit'
                   }
                   format.api { render_api_head :conflict }
                 end
               rescue ActiveRecord::RecordNotSaved
                 respond_to do |format|
                   format.html { render :action => 'edit' }
                   format.api { render_validation_errors(@content) }
                 end
               end
               # rename a page
               def rename
                 return render_403 unless editable?
                 @page.redirect_existing_links = true
                 # used to display the *original* title if some AR validation errors occur
                 @original_title = @page.pretty_title
                 if request.post? && @page.update_attributes(params[:wiki_page])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to project_wiki_page_path(@project, @page.title)
                 end
               end
               def protect
                 @page.update_attribute :protected, params[:protected]
                 redirect_to project_wiki_page_path(@project, @page.title)
               end
               # show page history
               def history
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new @version_count, per_page_option, params['page']
                 # don't load text
                 @versions = @page.content.versions.
                   select("id, author_id, comments, updated_on, version").
                   reorder('version DESC').
                   limit(@version_pages.per_page + 1).
                   offset(@version_pages.offset).
                   all
                 render :layout => false if request.xhr?
               end
               def diff
                 @diff = @page.diff(params[:version], params[:version_from])
                 render_404 unless @diff
               end
               def annotate
                 @annotate = @page.annotate(params[:version])
                 render_404 unless @annotate
               end
               # Removes a wiki page and its history
               # Children can be either set as root pages, removed or reassigned to another parent page
               def destroy
                 return render_403 unless editable?
                 @descendants_count = @page.descendants.size
                 if @descendants_count > 0
                   case params[:todo]
                   when 'nullify'
                     # Nothing to do
                   when 'destroy'
                     # Removes all its descendants
                     @page.descendants.each(&:destroy)
                   when 'reassign'
                     # Reassign children to another parent page
                     reassign_to = @wiki.pages.find_by_id(params[:reassign_to_id].to_i)
                     return unless reassign_to
                     @page.children.each do |child|
                       child.update_attribute(:parent, reassign_to)
                     end
                   else
                     @reassignable_to = @wiki.pages - @page.self_and_descendants
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @page.destroy
                 respond_to do |format|
                   format.html { redirect_to project_wiki_index_path(@project) }
                   format.api { render_api_ok }
                 end
               end
               def destroy_version
                 return render_403 unless editable?
                 @content = @page.content_for_version(params[:version])
                 @content.destroy
                 redirect_to_referer_or history_project_wiki_page_path(@project, @page.title)
               end
               # Export wiki to a single pdf or html file
               def export
                 @pages = @wiki.pages.all(:order => 'title', :include => [:content, {:attachments => :author}])
                 respond_to do |format|
                   format.html {
                     export = render_to_string :action => 'export_multiple', :layout => false
                     send_data(export, :type => 'text/html', :filename => "wiki.html")
                   }
                   format.pdf {
                     send_data(wiki_pages_to_pdf(@pages, @project), :type => 'application/pdf', :filename => "#{@project.identifier}.pdf")
                   }
                 end
               end
               def preview
                 page = @wiki.find_page(params[:id])
                 # page is nil when previewing a new page
                 return render_403 unless page.nil? || editable?(page)
                 if page
                   @attachments += page.attachments
                   @previewed = page.content
                 end
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 return render_403 unless editable?
                 attachments = Attachment.attach_files(@page, params[:attachments])
                 render_attachment_warning_if_needed(@page)
                 redirect_to :action => 'show', :id => @page.title, :project_id => @project
               end
             private
               def find_wiki
                 @project = Project.find(params[:project_id])
                 @wiki = @project.wiki
                 render_404 unless @wiki
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Finds the requested page or a new page if it doesn't exist
               def find_existing_or_new_page
                 @page = @wiki.find_or_new_page(params[:id])
                 if @wiki.page_found_with_redirect?
                   redirect_to params.update(:id => @page.title)
                 end
               end
               # Finds the requested page and returns a 404 error if it doesn't exist
               def find_existing_page
                 @page = @wiki.find_page(params[:id])
                 if @page.nil?
                   render_404
                   return
                 end
                 if @wiki.page_found_with_redirect?
                   redirect_to params.update(:id => @page.title)
                 end
               end
               # Returns true if the current user is allowed to edit the page, otherwise false
               def editable?(page = @page)
                 page.editable_by?(User.current)
               end
               # Returns the default content of a new wiki page
               def initial_page_content(page)
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper unless self.instance_of?(helper)
                 helper.instance_method(:initial_page_content).bind(self).call(page)
               end
               def load_pages_for_index
                 @pages = @wiki.pages.with_updated_on.reorder("#{WikiPage.table_name}.title").includes(:wiki => :project).includes(:parent).all
               end
             end

app/models/wiki_page.rb +2 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'diff'
             require 'enumerator'
             class WikiPage < ActiveRecord::Base
               include Redmine::SafeAttributes
               belongs_to :wiki
               has_one :content, :class_name => 'WikiContent', :foreign_key => 'page_id', :dependent => :destroy
               acts_as_attachable :delete_permission => :delete_wiki_pages_attachments
               acts_as_tree :dependent => :nullify, :order => 'title'
               acts_as_watchable
               acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},
                             :description => :text,
                             :datetime => :created_on,
                             :url => Proc.new {|o| {:controller => 'wiki', :action => 'show', :project_id => o.wiki.project, :id => o.title}}
               acts_as_searchable :columns => ['title', "#{WikiContent.table_name}.text"],
                                  :include => [{:wiki => :project}, :content],
                                  :permission => :view_wiki_pages,
                                  :project_key => "#{Wiki.table_name}.project_id"
               attr_accessor :redirect_existing_links
               validates_presence_of :title
               validates_format_of :title, :with => /\A[^,\.\/\?\;\|\s]*\z/
               validates_uniqueness_of :title, :scope => :wiki_id, :case_sensitive => false
               validates_associated :content
               validate :validate_parent_title
               before_destroy :remove_redirects
               before_save    :handle_redirects
               # eager load information about last updates, without loading text
               scope :with_updated_on, lambda {
                 select("#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on, #{WikiContent.table_name}.version").
                   joins("LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id")
               }
               # Wiki pages that are protected by default
               DEFAULT_PROTECTED_PAGES = %w(sidebar)
               safe_attributes 'parent_id', 'parent_title',
                 :if => lambda {|page, user| page.new_record? || user.allowed_to?(:rename_wiki_pages, page.project)}
               def initialize(attributes=nil, *args)
                 super
                 if new_record? && DEFAULT_PROTECTED_PAGES.include?(title.to_s.downcase)
                   self.protected = true
                 end
               end
               def visible?(user=User.current)
                 !user.nil? && user.allowed_to?(:view_wiki_pages, project)
               end
               def title=(value)
                 value = Wiki.titleize(value)
                 @previous_title = read_attribute(:title) if @previous_title.blank?
                 write_attribute(:title, value)
               end
               def handle_redirects
                 self.title = Wiki.titleize(title)
                 # Manage redirects if the title has changed
                 if !@previous_title.blank? && (@previous_title != title) && !new_record?
                   # Update redirects that point to the old title
                   wiki.redirects.find_all_by_redirects_to(@previous_title).each do |r|
                     r.redirects_to = title
                     r.title == r.redirects_to ? r.destroy : r.save
                   end
                   # Remove redirects for the new title
                   wiki.redirects.find_all_by_title(title).each(&:destroy)
                   # Create a redirect to the new title
                   wiki.redirects << WikiRedirect.new(:title => @previous_title, :redirects_to => title) unless redirect_existing_links == "0"
                   @previous_title = nil
                 end
               end
               def remove_redirects
                 # Remove redirects to this page
                 wiki.redirects.find_all_by_redirects_to(title).each(&:destroy)
               end
               def pretty_title
                 WikiPage.pretty_title(title)
               end
               def content_for_version(version=nil)
                 result = content.versions.find_by_version(version.to_i) if version
                 result ||= content
                 result
               end
               def diff(version_to=nil, version_from=nil)
                 version_to = version_to ? version_to.to_i : self.content.version
                 content_to = content.versions.find_by_version(version_to)
                 content_from = version_from ? content.versions.find_by_version(version_from.to_i) : content_to.try(:previous)
                 return nil unless content_to && content_from
                 if content_from.version > content_to.version
                   content_to, content_from = content_from, content_to
                 end
                 (content_to && content_from) ? WikiDiff.new(content_to, content_from) : nil
               end
               def annotate(version=nil)
                 version = version ? version.to_i : self.content.version
                 c = content.versions.find_by_version(version)
                 c ? WikiAnnotate.new(c) : nil
               end
               def self.pretty_title(str)
                 (str && str.is_a?(String)) ? str.tr('_', ' ') : str
               end
               def project
                 wiki.project
               end
               def text
                 content.text if content
               end
               def updated_on
                 unless @updated_on
                   if time = read_attribute(:updated_on)
                     # content updated_on was eager loaded with the page
                     begin
                       @updated_on = (self.class.default_timezone == :utc ? Time.parse(time.to_s).utc : Time.parse(time.to_s).localtime)
                     rescue
                     end
                   else
                     @updated_on = content && content.updated_on
                   end
                 end
                 @updated_on
               end
               # Returns true if usr is allowed to edit the page, otherwise false
               def editable_by?(usr)
                 !protected? || usr.allowed_to?(:protect_wiki_pages, wiki.project)
               end
               def attachments_deletable?(usr=User.current)
                 editable_by?(usr) && super(usr)
               end
               def parent_title
                 @parent_title || (self.parent && self.parent.pretty_title)
               end
               def parent_title=(t)
                 @parent_title = t
                 parent_page = t.blank? ? nil : self.wiki.find_page(t)
                 self.parent = parent_page
               end
               # Saves the page and its content if text was changed
-              def save_with_content
+              def save_with_content(content)
                 ret = nil
                 transaction do
+                  self.content = content
                   if new_record?
                     # Rails automatically saves associated content
                     ret = save
                   else
                     ret = save && (content.text_changed? ? content.save : true)
                   end
                   raise ActiveRecord::Rollback unless ret
                 end
                 ret
               end
               protected
               def validate_parent_title
                 errors.add(:parent_title, :invalid) if !@parent_title.blank? && parent.nil?
                 errors.add(:parent_title, :circular_dependency) if parent && (parent == self || parent.ancestors.include?(self))
                 errors.add(:parent_title, :not_same_project) if parent && (parent.wiki_id != wiki_id)
               end
             end
             class WikiDiff < Redmine::Helpers::Diff
               attr_reader :content_to, :content_from
               def initialize(content_to, content_from)
                 @content_to = content_to
                 @content_from = content_from
                 super(content_to.text, content_from.text)
               end
             end
             class WikiAnnotate
               attr_reader :lines, :content
               def initialize(content)
                 @content = content
                 current = content
                 current_lines = current.text.split(/\r?\n/)
                 @lines = current_lines.collect {|t| [nil, nil, t]}
                 positions = []
                 current_lines.size.times {|i| positions << i}
                 while (current.previous)
                   d = current.previous.text.split(/\r?\n/).diff(current.text.split(/\r?\n/)).diffs.flatten
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '+' && positions[line] && positions[line] != -1
                       if @lines[positions[line]][0].nil?
                         @lines[positions[line]][0] = current.version
                         @lines[positions[line]][1] = current.author
                       end
                     end
                   end
                   d.each_slice(3) do |s|
                     sign, line = s[0], s[1]
                     if sign == '-'
                       positions.insert(line, -1)
                     else
                       positions[line] = nil
                     end
                   end
                   positions.compact!
                   # Stop if every line is annotated
                   break unless @lines.detect { |line| line[0].nil? }
                   current = current.previous
                 end
                 @lines.each { |line|
                   line[0] ||= current.version
                   # if the last known version is > 1 (eg. history was cleared), we don't know the author
                   line[1] ||= current.author if current.version == 1
                 }
               end
             end

test/functional/wiki_controller_test.rb +23 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class WikiControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles,
                        :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                        :wiki_content_versions, :attachments
               def setup
                 User.current = nil
               end
               def test_show_start_page
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'h1', :content => /CookBook documentation/
                 # child_pages macro
                 assert_tag :ul, :attributes => { :class => 'pages-hierarchy' },
                            :child => { :tag => 'li',
                                        :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Page_with_an_inline_image' },
                                                                 :content => 'Page with an inline image' } }
               end
               def test_export_link
                 Role.anonymous.add_permission! :export_wiki_pages
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_tag 'a', :attributes => {:href => '/projects/ecookbook/wiki/CookBook_documentation.txt'}
               end
               def test_show_page_with_name
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'h1', :content => /Another page/
                 # Included page with an inline image
                 assert_tag :tag => 'p', :content => /This is an inline image/
                 assert_tag :tag => 'img', :attributes => { :src => '/attachments/download/3/logo.gif',
                                                            :alt => 'This is a logo' }
               end
               def test_show_old_version
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 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/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/3', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_old_version_with_attachments
                 page = WikiPage.find(4)
                 assert page.attachments.any?
                 content = page.content
                 content.text = "update"
                 content.save!
                 get :show, :project_id => 'ecookbook', :id => page.title, :version => '1'
                 assert_kind_of WikiContent::Version, assigns(:content)
                 assert_response :success
                 assert_template 'show'
               end
               def test_show_old_version_without_permission_should_be_denied
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fprojects%2Fecookbook%2Fwiki%2FCookBook_documentation%2F2'
               end
               def test_show_first_version
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a', :text => /Previous/, :count => 0
                 assert_select 'a', :text => /diff/, :count => 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_redirected_page
                 WikiRedirect.create!(:wiki_id => 1, :title => 'Old_title', :redirects_to => 'Another_page')
                 get :show, :project_id => 'ecookbook', :id => 'Old_title'
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
               end
               def test_show_with_sidebar
                 page = Project.find(1).wiki.pages.new(:title => 'Sidebar')
                 page.content = WikiContent.new(:text => 'Side bar content for test_show_with_sidebar')
                 page.save!
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_tag :tag => 'div', :attributes => {:id => 'sidebar'},
                                           :content => /Side bar content for test_show_with_sidebar/
               end
               def test_show_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections'
                 assert_no_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=1'
                 }
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=3'
                 }
               end
               def test_show_current_version_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 3
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
               end
               def test_show_old_version_should_not_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_no_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
               end
               def test_show_unexistent_page_without_edit_right
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response 404
               end
               def test_show_unexistent_page_with_edit_right
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_show_unexistent_page_with_parent_should_preselect_parent
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'select', :attributes => {:name => 'wiki_page[parent_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '2', :selected => 'selected'}}
               end
               def test_show_should_not_show_history_without_permission
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_response 302
               end
+              def test_show_page_without_content_should_display_the_edit_form
+                @request.session[:user_id] = 2
+                WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
+                get :show, :project_id => 1, :id => 'NoContent'
+                assert_response :success
+                assert_template 'edit'
+                assert_select 'textarea[name=?]', 'content[text]'
+              end
               def test_create_page
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0}
                   end
                 end
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'New_page'
                 page = Project.find(1).wiki.find_page('New page')
                 assert !page.new_record?
                 assert_not_nil page.content
                 assert_nil page.parent
                 assert_equal 'Created the page', page.content.comments
               end
               def test_create_page_with_attachments
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'Attachment.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0},
                                 :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                   end
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal 1, page.attachments.count
                 assert_equal 'testfile.txt', page.attachments.first.filename
               end
               def test_create_page_with_parent
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   put :update, :project_id => 1, :id => 'New page',
                     :content => {:text => "h1. New page\n\nThis is a new page", :version => 0},
                     :wiki_page => {:parent_id => 2}
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal WikiPage.find(2), page.parent
               end
               def test_edit_page
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => "\n"+WikiPage.find_by_title('Another_page').content.text
               end
               def test_edit_section
                 @request.session[:user_id] = 2
                 get :edit, :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)
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => "\n"+section
                 assert_tag 'input',
                   :attributes => { :name => 'section', :type => 'hidden', :value => '2' }
                 assert_tag 'input',
                   :attributes => { :name => 'section_hash', :type => 'hidden', :value => hash }
               end
               def test_edit_invalid_section_should_respond_with_404
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 10
                 assert_response 404
               end
               def test_update_page
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
               end
               def test_update_page_with_parent
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'a' * 300,  # failure here, comment is too long
                           :text => 'edited',
                           :version => 1
                         }
                       end
                     end
                   end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Comment is too long/}
                 assert_tag :tag => 'textarea', :attributes => {:id => 'content_text'}, :content => "\nedited"
                 assert_tag :tag => 'input', :attributes => {:id => 'content_version', :value => '1'}
               end
               def test_update_page_with_parent_change_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => '',
                           :text => Wiki.find(1).find_page('Another_page').content.text,
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_attachments_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       assert_difference 'Attachment.count' do
                         put :update, :project_id => 1,
                           :id => 'Another_page',
                           :content => {
                             :comments => '',
                             :text => Wiki.find(1).find_page('Another_page').content.text,
                             :version => 1
                           },
                           :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                       end
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
               end
               def test_update_stale_page_should_not_raise_an_error
                 @request.session[:user_id] = 2
                 c = Wiki.find(1).find_page('Another_page').content
                 c.text = 'Previous text'
                 c.save!
                 assert_equal 2, c.version
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'My comments',
                           :text => 'Text should not be lost',
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :div,
                   :attributes => { :class => /error/ },
                   :content => /Data has been updated by another user/
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => /Text should not be lost/
                 assert_tag 'input',
                   :attributes => { :name => 'content[comments]', :value => 'My comments' }
                 c.reload
                 assert_equal 'Previous text', c.text
                 assert_equal 2, c.version
               end
+              def test_update_page_without_content_should_create_content
+                @request.session[:user_id] = 2
+                page = WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
+                assert_no_difference 'WikiPage.count' do
+                  assert_difference 'WikiContent.count' do
+                    put :update, :project_id => 1, :id => 'NoContent', :content => {:text => 'Some content'}
+                    assert_response 302
+                  end
+                end
+                assert_equal 'Some content', page.reload.content.text
+              end
               def test_update_section
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections'
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.reload.content.text
               end
               def test_update_section_should_allow_stale_page_update
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 2 # Current version is 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections'
                 page.reload
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.content.text
                 assert_equal 4, page.content.version
               end
               def test_update_section_should_not_allow_stale_section_update
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :comments => 'My comments',
                           :text => "Text should not be lost",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => Digest::MD5.hexdigest("wrong hash")
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :div,
                   :attributes => { :class => /error/ },
                   :content => /Data has been updated by another user/
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => /Text should not be lost/
                 assert_tag 'input',
                   :attributes => { :name => 'content[comments]', :value => 'My comments' }
               end
               def test_preview
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'CookBook_documentation',
                                                :content => { :comments => '',
                                                              :text => 'this is a *previewed text*',
                                                              :version => 3 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_tag :tag => 'strong', :content => /previewed text/
               end
               def test_preview_new_page
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'New page',
                                                :content => { :text => 'h1. New page',
                                                              :comments => '',
                                                              :version => 0 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_tag :tag => 'h1', :content => /New page/
               end
               def test_history
                 @request.session[:user_id] = 2
                 get :history, :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 "input[type=submit][name=commit]"
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => '2'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => 'Delete'
                 end
               end
               def test_history_with_one_version
                 @request.session[:user_id] = 2
                 get :history, :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 "input[type=submit][name=commit]", false
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => '1'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => 'Delete', :count => 0
                 end
               end
               def test_diff
                 content = WikiPage.find(1).content
                 assert_difference 'WikiContent::Version.count', 2 do
                   content.text = "Line removed\nThis is a sample text for testing diffs"
                   content.save!
                   content.text = "This is a sample text for testing diffs\nLine added"
                   content.save!
                 end
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => content.version, :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
               def test_diff_with_invalid_version_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_diff_with_invalid_version_from_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99', :version_from => '98'
                 assert_response 404
               end
               def test_annotate
                 get :annotate, :project_id => 1, :id =>  'CookBook_documentation', :version => 2
                 assert_response :success
                 assert_template 'annotate'
                 # Line 1
                 assert_tag :tag => 'tr', :child => {
                   :tag => 'th', :attributes => {:class => 'line-num'}, :content => '1', :sibling => {
                     :tag => 'td', :attributes => {:class => 'author'}, :content => /John Smith/, :sibling => {
                       :tag => 'td', :content => /h1\. CookBook documentation/
                     }
                   }
                 }
                 # Line 5
                 assert_tag :tag => 'tr', :child => {
                   :tag => 'th', :attributes => {:class => 'line-num'}, :content => '5', :sibling => {
                     :tag => 'td', :attributes => {:class => 'author'}, :content => /Redmine Admin/, :sibling => {
                       :tag => 'td', :content => /Some updated \[\[documentation\]\] here/
                     }
                   }
                 }
               end
               def test_annotate_with_invalid_version_should_respond_with_404
                 get :annotate, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_get_rename
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'rename'
                 assert_tag 'option',
                   :attributes => {:value => ''},
                   :content => '',
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
                 assert_no_tag 'option',
                   :attributes => {:selected => 'selected'},
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
               end
               def test_get_rename_child_page
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Child_1'
                 assert_response :success
                 assert_template 'rename'
                 assert_tag 'option',
                   :attributes => {:value => ''},
                   :content => '',
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
                 assert_tag 'option',
                   :attributes => {:value => '2', :selected => 'selected'},
                   :content => /Another page/,
                   :parent => {
                     :tag => 'select',
                     :attributes => {:name => 'wiki_page[parent_id]'}
                   }
               end
               def test_rename_with_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => 1 }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check redirects
                 assert_not_nil wiki.find_page('Another page')
                 assert_nil wiki.find_page('Another page', :with_redirect => false)
               end
               def test_rename_without_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => "0" }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check that there's no redirects
                 assert_nil wiki.find_page('Another page')
               end
               def test_rename_with_parent_assignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                   :wiki_page => { :title => 'Another page', :redirect_existing_links => "0", :parent_id => '4' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert_equal WikiPage.find(4), WikiPage.find_by_title('Another_page').parent
               end
               def test_rename_with_parent_unassignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Child_1',
                   :wiki_page => { :title => 'Child 1', :redirect_existing_links => "0", :parent_id => '' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Child_1'
                 assert_nil WikiPage.find_by_title('Child_1').parent
               end
               def test_destroy_a_page_without_children_should_not_ask_confirmation
                 @request.session[:user_id] = 2
                 delete :destroy, :project_id => 1, :id => 'Child_2'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
               end
               def test_destroy_parent_should_ask_confirmation
                 @request.session[:user_id] = 2
                 assert_no_difference('WikiPage.count') do
                   delete :destroy, :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]'
                   assert_select 'input[name=todo][value=reassign]'
                 end
               end
               def test_destroy_parent_with_nullify_should_delete_parent_only
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'nullify'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
               end
               def test_destroy_parent_with_cascade_should_delete_descendants
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -4) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'destroy'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_nil WikiPage.find_by_id(5)
               end
               def test_destroy_parent_with_reassign
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'reassign', :reassign_to_id => 1
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_equal WikiPage.find(1), WikiPage.find_by_id(5).parent
               end
               def test_destroy_version
                 @request.session[:user_id] = 2
                 assert_difference 'WikiContent::Version.count', -1 do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiPage.count' do
                       delete :destroy_version, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 2
                       assert_redirected_to '/projects/ecookbook/wiki/CookBook_documentation/history'
                     end
                   end
                 end
               end
               def test_index
                 get :index, :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_tag :ul, :attributes => { :class => 'pages-hierarchy' },
                                 :child => { :tag => 'li', :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/CookBook_documentation' },
                                                           :content => 'CookBook documentation' },
                                             :child => { :tag => 'ul',
                                                         :child => { :tag => 'li',
                                                                     :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Page_with_an_inline_image' },
                                                                                              :content => 'Page with an inline image' } } } },
                                 :child => { :tag => 'li', :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Another_page' },
                                                                                    :content => 'Another page' } }
               end
               def test_index_should_include_atom_link
                 get :index, :project_id => 'ecookbook'
                 assert_tag 'a', :attributes => { :href => '/projects/ecookbook/activity.atom?show_wiki_edits=1'}
               end
               def test_export_to_html
                 @request.session[:user_id] = 2
                 get :export, :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"
                 assert_select "a[name=?]", "Another_page"
                 assert_select "a[name=?]", "Page_with_an_inline_image"
               end
               def test_export_to_pdf
                 @request.session[:user_id] = 2
                 get :export, :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')
               end
               def test_export_without_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :export_wiki_pages
                 get :export, :project_id => 'ecookbook'
                 assert_response 403
               end
               def test_date_index
                 get :date_index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'date_index'
                 assert_not_nil assigns(:pages)
                 assert_not_nil assigns(:pages_by_date)
                 assert_tag 'a', :attributes => { :href => '/projects/ecookbook/activity.atom?show_wiki_edits=1'}
               end
               def test_not_found
                 get :show, :project_id => 999
                 assert_response 404
               end
               def test_protect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'Another_page')
                 assert !page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '1'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert page.reload.protected?
               end
               def test_unprotect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'CookBook_documentation')
                 assert page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '0'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert !page.reload.protected?
               end
               def test_show_page_with_edit_link
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'a', :attributes => { :href => '/projects/1/wiki/CookBook_documentation/edit' }
               end
               def test_show_page_without_edit_link
                 @request.session[:user_id] = 4
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_no_tag :tag => 'a', :attributes => { :href => '/projects/1/wiki/CookBook_documentation/edit' }
               end
               def test_show_pdf
                 @request.session[:user_id] = 2
                 get :show, :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']
               end
               def test_show_html
                 @request.session[:user_id] = 2
                 get :show, :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']
                 assert_tag 'h1', :content => 'CookBook documentation'
               end
               def test_show_versioned_html
                 @request.session[:user_id] = 2
                 get :show, :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_tag 'h1', :content => 'CookBook documentation'
               end
               def test_show_txt
                 @request.session[:user_id] = 2
                 get :show, :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']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_show_versioned_txt
                 @request.session[:user_id] = 2
                 get :show, :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
               end
               def test_edit_unprotected_page
                 # Non members can edit unprotected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_edit_protected_page_by_nonmember
                 # Non members can't edit protected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response 403
               end
               def test_edit_protected_page_by_member
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_history_of_non_existing_page_should_return_404
                 get :history, :project_id => 1, :id => 'Unknown_page'
                 assert_response 404
               end
               def test_add_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count' do
                   post :add_attachment, :project_id => 1, :id => 'CookBook_documentation',
                     :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                 end
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal Wiki.find(1).find_page('CookBook_documentation'), attachment.container
               end
             end

General Comments 0

Write
Preview

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

No TODOs yet

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

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