jro_apps/redmine Commit - r10504:9e3130872057

REST API for retrieving wiki pages (#7082)....

Jean-Philippe Lang -

r10504:9e3130872057

parent child

Context file:

r10504:9e3130872057

Collapse all files

app/views/wiki/index.api.rsb created 644 +13 0

@@ -0,0 +1,13
	1	api.array :wiki_pages do
	2	@pages.each do \|page\|
	3	api.wiki_page do
	4	api.title page.title
	5	if page.parent
	6	api.parent :title => page.parent.title
	7	end
	8	api.version page.version
	9	api.created_on page.created_on
	10	api.updated_on page.updated_on
	11	end
	12	end
	13	end

app/views/wiki/show.api.rsb created 644 +11 0

@@ -0,0 +1,11
	1	api.wiki_page do
	2	api.title @page.title
	3	if @page.parent
	4	api.parent :title => @page.parent.title
	5	end
	6	api.text @content.text
	7	api.version @content.version
	8	api.author(:id => @content.author_id, :name => @content.author.name)
	9	api.created_on @page.created_on
	10	api.updated_on @content.updated_on
	11	end

test/integration/api_test/wiki_pages_test.rb created 644 +85 0

@@ -0,0 +1,85
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2012 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.expand_path('../../../test_helper', __FILE__)
	19
	20	class ApiTest::WikiPagesTest < ActionController::IntegrationTest
	21	fixtures :projects, :users, :roles, :members, :member_roles,
	22	:enabled_modules, :wikis, :wiki_pages, :wiki_contents,
	23	:wiki_content_versions, :attachments
	24
	25	def setup
	26	Setting.rest_api_enabled = '1'
	27	end
	28
	29	test "GET /projects/:project_id/wiki/index.xml should return wiki pages" do
	30	get '/projects/ecookbook/wiki/index.xml'
	31	assert_response :success
	32	assert_equal 'application/xml', response.content_type
	33	assert_select 'wiki_pages[type=array]' do
	34	assert_select 'wiki_page', :count => Wiki.find(1).pages.count
	35	assert_select 'wiki_page' do
	36	assert_select 'title', :text => 'CookBook_documentation'
	37	assert_select 'version', :text => '3'
	38	assert_select 'created_on'
	39	assert_select 'updated_on'
	40	end
	41	end
	42	end
	43
	44	test "GET /projects/:project_id/wiki/:title.xml should return wiki page" do
	45	get '/projects/ecookbook/wiki/CookBook_documentation.xml'
	46	assert_response :success
	47	assert_equal 'application/xml', response.content_type
	48	assert_select 'wiki_page' do
	49	assert_select 'title', :text => 'CookBook_documentation'
	50	assert_select 'version', :text => '3'
	51	assert_select 'text'
	52	assert_select 'author'
	53	assert_select 'created_on'
	54	assert_select 'updated_on'
	55	end
	56	end
	57
	58	test "GET /projects/:project_id/wiki/:title.xml with unknown title and edit permission should respond with 404" do
	59	get '/projects/ecookbook/wiki/Invalid_Page.xml', {}, credentials('jsmith')
	60	assert_response 404
	61	assert_equal 'application/xml', response.content_type
	62	end
	63
	64	test "GET /projects/:project_id/wiki/:title/:version.xml should return wiki page version" do
	65	get '/projects/ecookbook/wiki/CookBook_documentation/2.xml'
	66	assert_response :success
	67	assert_equal 'application/xml', response.content_type
	68	assert_select 'wiki_page' do
	69	assert_select 'title', :text => 'CookBook_documentation'
	70	assert_select 'version', :text => '2'
	71	assert_select 'text'
	72	assert_select 'author'
	73	assert_select 'created_on'
	74	assert_select 'updated_on'
	75	end
	76	end
	77
	78	test "GET /projects/:project_id/wiki/:title/:version.xml without permission should be denied" do
	79	Role.anonymous.remove_permission! :view_wiki_edits
	80
	81	get '/projects/ecookbook/wiki/CookBook_documentation/2.xml'
	82	assert_response 401
	83	assert_equal 'application/xml', response.content_type
	84	end
	85	end

app/controllers/wiki_controller.rb +15 -6

             # Redmine - project management software
             # Copyright (C) 2006-2012  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'
             # 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
               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
-                @pages_by_parent_id = @pages.group_by(&:parent_id)
+                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 User.current.allowed_to?(:edit_wiki_pages, @project) && editable?
+                  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)
-                  # Redirects user to the current version if he's not allowed to view previous versions
+                  deny_access
-                  redirect_to :version => nil
                   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?
-                render :action => 'show'
+                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.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
                 @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?
                 @page.content = WikiContent.new(:page => @page) if @page.new_record?
                 @page.safe_attributes = params[:wiki_page]
                 @content = @page.content_for_version(params[:version])
                 @content.text = initial_page_content(@page) if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 if !@page.new_record? && params[:content].present? && @content.text == params[:content][:text]
                   attachments = Attachment.attach_files(@page, params[:attachments])
                   render_attachment_warning_if_needed(@page)
                   # don't save content if text wasn't changed
                   @page.save
                   redirect_to :action => 'show', :project_id => @project, :id => @page.title
                   return
                 end
                 @content.comments = params[:content][:comments]
                 @text = params[:content][: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 = params[:content][:version]
                   @content.text = @text
                 end
                 @content.author = User.current
                 @page.content = @content
                 if @page.save
                   attachments = Attachment.attach_files(@page, params[:attachments])
                   render_attachment_warning_if_needed(@page)
                   call_hook(:controller_wiki_edit_after_save, { :params => params, :page => @page})
                   redirect_to :action => 'show', :project_id => @project, :id => @page.title
                 else
                   render :action => 'edit'
                 end
               rescue ActiveRecord::StaleObjectError, Redmine::WikiFormatting::StaleSectionError
                 # Optimistic locking exception
                 flash.now[:error] = l(:notice_locking_conflict)
                 render :action => 'edit'
               rescue ActiveRecord::RecordNotSaved
                 render :action => 'edit'
               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 :action => 'show', :project_id => @project, :id => @page.title
                 end
               end
               def protect
                 @page.update_attribute :protected, params[:protected]
                 redirect_to :action => 'show', :project_id => @project, :id => @page.title
               end
               # show page history
               def history
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, per_page_option, params['p']
                 # don't load text
                 @versions = @page.content.versions.find :all,
                                                         :select => "id, author_id, comments, updated_on, version",
                                                         :order => 'version DESC',
                                                         :limit  =>  @version_pages.items_per_page + 1,
                                                         :offset =>  @version_pages.current.offset
                 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
                     return
                   end
                 end
                 @page.destroy
                 redirect_to :action => 'index', :project_id => @project
               end
               def destroy_version
                 return render_403 unless editable?
                 @content = @page.content_for_version(params[:version])
                 @content.destroy
                 redirect_to_referer_or :action => 'history', :id => @page.title, :project_id => @project
               end
               # Export wiki to a single pdf or html file
               def export
                 @pages = @wiki.pages.all(:order => 'title', :include => [:content, :attachments], :limit => 75)
                 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
                   @attachements = 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.all(:order => 'title', :include => {:wiki => :project})
+                @pages = @wiki.pages.with_updated_on.order("#{WikiPage.table_name}.title").includes(:wiki => :project).includes(:parent).all
               end
             end

app/models/wiki_page.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 => /^[^,\.\/\?\;\|\s]*$/
               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, {
-                :select => "#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on",
+                :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',
                 :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.previous
                 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
               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 +7 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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__)
             require 'wiki_controller'
             # Re-raise errors caught by the controller.
             class WikiController; def rescue_action(e) raise e end; end
             class WikiControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles,
                        :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                        :wiki_content_versions, :attachments
               def setup
                 @controller = WikiController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 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',
                                                            :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_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_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_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_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_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

test/integration/routing/wiki_test.rb +28 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 RoutingWikiTest < ActionController::IntegrationTest
               def test_wiki_matching
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki" },
                     { :controller => 'wiki', :action => 'show', :project_id => '567' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/lalala" },
                     { :controller => 'wiki', :action => 'show', :project_id => '567',
                       :id => 'lalala' }
                     )
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/lalala.pdf" },
                     { :controller => 'wiki', :action => 'show', :project_id => '567',
                       :id => 'lalala', :format => 'pdf' }
                     )
                 assert_routing(
+                    { :method => 'get', :path => "/projects/567/wiki/lalala.xml" },
+                    { :controller => 'wiki', :action => 'show', :project_id => '567',
+                      :id => 'lalala', :format => 'xml' }
+                    )
+                assert_routing(
+                    { :method => 'get', :path => "/projects/567/wiki/lalala.json" },
+                    { :controller => 'wiki', :action => 'show', :project_id => '567',
+                      :id => 'lalala', :format => 'json' }
+                    )
+                assert_routing(
                      { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/diff" },
                      { :controller => 'wiki', :action => 'diff', :project_id => '1',
                        :id => 'CookBook_documentation' }
                    )
                 assert_routing(
                      { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/2" },
                      { :controller => 'wiki', :action => 'show', :project_id => '1',
                        :id => 'CookBook_documentation', :version => '2' }
                    )
                 assert_routing(
+                     { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/2.xml" },
+                     { :controller => 'wiki', :action => 'show', :project_id => '1',
+                       :id => 'CookBook_documentation', :version => '2', :format => 'xml' }
+                   )
+                assert_routing(
+                     { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/2.json" },
+                     { :controller => 'wiki', :action => 'show', :project_id => '1',
+                       :id => 'CookBook_documentation', :version => '2', :format => 'json' }
+                   )
+                assert_routing(
                      { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/2/diff" },
                      { :controller => 'wiki', :action => 'diff', :project_id => '1',
                        :id => 'CookBook_documentation', :version => '2' }
                    )
                 assert_routing(
                      { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/2/annotate" },
                      { :controller => 'wiki', :action => 'annotate', :project_id => '1',
                        :id => 'CookBook_documentation', :version => '2' }
                    )
               end
               def test_wiki_misc
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/date_index" },
                     { :controller => 'wiki', :action => 'date_index', :project_id => '567' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/export" },
                     { :controller => 'wiki', :action => 'export', :project_id => '567' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/export.pdf" },
                     { :controller => 'wiki', :action => 'export', :project_id => '567', :format => 'pdf' }
                   )
                 assert_routing(
                      { :method => 'get', :path => "/projects/567/wiki/index" },
                      { :controller => 'wiki', :action => 'index', :project_id => '567' }
                    )
+                assert_routing(
+                     { :method => 'get', :path => "/projects/567/wiki/index.xml" },
+                     { :controller => 'wiki', :action => 'index', :project_id => '567', :format => 'xml' }
+                   )
+                assert_routing(
+                     { :method => 'get', :path => "/projects/567/wiki/index.json" },
+                     { :controller => 'wiki', :action => 'index', :project_id => '567', :format => 'json' }
+                   )
               end
               def test_wiki_resources
                 assert_routing(
                     { :method => 'get', :path => "/projects/567/wiki/my_page/edit" },
                     { :controller => 'wiki', :action => 'edit', :project_id => '567',
                       :id => 'my_page' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/1/wiki/CookBook_documentation/history" },
                     { :controller => 'wiki', :action => 'history', :project_id => '1',
                       :id => 'CookBook_documentation' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/22/wiki/ladida/rename" },
                     { :controller => 'wiki', :action => 'rename', :project_id => '22',
                       :id => 'ladida' }
                   )
                 ["post", "put"].each do |method|
                   assert_routing(
                       { :method => method, :path => "/projects/567/wiki/CookBook_documentation/preview" },
                       { :controller => 'wiki', :action => 'preview', :project_id => '567',
                         :id => 'CookBook_documentation' }
                     )
                 end
                 assert_routing(
                     { :method => 'post', :path => "/projects/22/wiki/ladida/rename" },
                     { :controller => 'wiki', :action => 'rename', :project_id => '22',
                       :id => 'ladida' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/projects/22/wiki/ladida/protect" },
                     { :controller => 'wiki', :action => 'protect', :project_id => '22',
                       :id => 'ladida' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/projects/22/wiki/ladida/add_attachment" },
                     { :controller => 'wiki', :action => 'add_attachment', :project_id => '22',
                       :id => 'ladida' }
                   )
                 assert_routing(
                     { :method => 'put', :path => "/projects/567/wiki/my_page" },
                     { :controller => 'wiki', :action => 'update', :project_id => '567',
                       :id => 'my_page' }
                   )
                 assert_routing(
                     { :method => 'delete', :path => "/projects/22/wiki/ladida" },
                     { :controller => 'wiki', :action => 'destroy', :project_id => '22',
                       :id => 'ladida' }
                   )
                 assert_routing(
                     { :method => 'delete', :path => "/projects/22/wiki/ladida/3" },
                     { :controller => 'wiki', :action => 'destroy_version', :project_id => '22',
                       :id => 'ladida', :version => '3' }
                   )
               end
             end

test/unit/wiki_page_test.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 WikiPageTest < ActiveSupport::TestCase
               fixtures :projects, :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions
               def setup
                 @wiki = Wiki.find(1)
                 @page = @wiki.pages.first
               end
               def test_create
                 page = WikiPage.new(:wiki => @wiki)
                 assert !page.save
                 assert_equal 1, page.errors.count
                 page.title = "Page"
                 assert page.save
                 page.reload
                 assert !page.protected?
                 @wiki.reload
                 assert @wiki.pages.include?(page)
               end
               def test_sidebar_should_be_protected_by_default
                 page = @wiki.find_or_new_page('sidebar')
                 assert page.new_record?
                 assert page.protected?
               end
               def test_find_or_new_page
                 page = @wiki.find_or_new_page("CookBook documentation")
                 assert_kind_of WikiPage, page
                 assert !page.new_record?
                 page = @wiki.find_or_new_page("Non existing page")
                 assert_kind_of WikiPage, page
                 assert page.new_record?
               end
               def test_parent_title
                 page = WikiPage.find_by_title('Another_page')
                 assert_nil page.parent_title
                 page = WikiPage.find_by_title('Page_with_an_inline_image')
                 assert_equal 'CookBook documentation', page.parent_title
               end
               def test_assign_parent
                 page = WikiPage.find_by_title('Another_page')
                 page.parent_title = 'CookBook documentation'
                 assert page.save
                 page.reload
                 assert_equal WikiPage.find_by_title('CookBook_documentation'), page.parent
               end
               def test_unassign_parent
                 page = WikiPage.find_by_title('Page_with_an_inline_image')
                 page.parent_title = ''
                 assert page.save
                 page.reload
                 assert_nil page.parent
               end
               def test_parent_validation
                 page = WikiPage.find_by_title('CookBook_documentation')
                 # A page that doesn't exist
                 page.parent_title = 'Unknown title'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.invalid'),
                                page.errors[:parent_title]
                 # A child page
                 page.parent_title = 'Page_with_an_inline_image'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                page.errors[:parent_title]
                 # The page itself
                 page.parent_title = 'CookBook_documentation'
                 assert !page.save
                 assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                page.errors[:parent_title]
                 page.parent_title = 'Another_page'
                 assert page.save
               end
               def test_destroy
                 page = WikiPage.find(1)
                 page.destroy
                 assert_nil WikiPage.find_by_id(1)
                 # make sure that page content and its history are deleted
                 assert WikiContent.find_all_by_page_id(1).empty?
                 assert WikiContent.versioned_class.find_all_by_page_id(1).empty?
               end
               def test_destroy_should_not_nullify_children
                 page = WikiPage.find(2)
                 child_ids = page.child_ids
                 assert child_ids.any?
                 page.destroy
                 assert_nil WikiPage.find_by_id(2)
                 children = WikiPage.find_all_by_id(child_ids)
                 assert_equal child_ids.size, children.size
                 children.each do |child|
                   assert_nil child.parent_id
                 end
               end
               def test_updated_on_eager_load
                 page = WikiPage.with_updated_on.first(:order => 'id')
                 assert page.is_a?(WikiPage)
                 assert_not_nil page.read_attribute(:updated_on)
                 assert_equal Time.gm(2007, 3, 6, 23, 10, 51), page.content.updated_on
                 assert_equal page.content.updated_on, page.updated_on
+                assert_not_nil page.read_attribute(:version)
               end
               def test_descendants
                 page = WikiPage.create!(:wiki => @wiki, :title => 'Parent')
                 child1 = WikiPage.create!(:wiki => @wiki, :title => 'Child1', :parent => page)
                 child11 = WikiPage.create!(:wiki => @wiki, :title => 'Child11', :parent => child1)
                 child111 = WikiPage.create!(:wiki => @wiki, :title => 'Child111', :parent => child11)
                 child2 = WikiPage.create!(:wiki => @wiki, :title => 'Child2', :parent => page)
                 assert_equal %w(Child1 Child11 Child111 Child2), page.descendants.map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2), page.descendants(nil).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child2), page.descendants(2).map(&:title).sort
                 assert_equal %w(Child1 Child2), page.descendants(1).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants.map(&:title).sort
                 assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants(nil).map(&:title).sort
                 assert_equal %w(Child1 Child11 Child2 Parent), page.self_and_descendants(2).map(&:title).sort
                 assert_equal %w(Child1 Child2 Parent), page.self_and_descendants(1).map(&:title).sort
               end
               def test_diff_for_page_with_deleted_version_should_pick_the_previous_available_version
                 WikiContent::Version.find_by_page_id_and_version(1, 2).destroy
                 page = WikiPage.find(1)
                 diff = page.diff(3)
                 assert_not_nil diff
                 assert_equal 3, diff.content_to.version
                 assert_equal 1, diff.content_from.version
               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