deac/instiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Moved old tests and app/model out of the way

Browse source
This commit is contained in:
Alexey Verkhovsky 2005-08-02 07:59:22 +00:00
parent 21adee88d4
commit 6d8190c096
40 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

9
test/all_tests.rb
View file

@ -1,9 +0,0 @@
require 'test_helper'
require 'find'
test_root = File.dirname(__FILE__)
Find.find(test_root) { |path|
if File.file?(path) and path =~ /.*_test\.rb$/
load path
end
}

BIN
test/fixtures/rails.gif vendored
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 8.3 KiB

228
test/functional/admin_controller_test.rb
View file

@ -1,228 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'admin_controller'
# Raise errors beyond the default web-based presentation
class AdminController; def rescue_action(e) logger.error(e); raise e end; end
class AdminControllerTest < Test::Unit::TestCase
def setup
setup_test_wiki
setup_controller_test
end
def tear_down
tear_down_wiki
end
def test_create_system_form_displayed
ApplicationController.wiki = WikiServiceWithNoPersistence.new
process('create_system')
assert_success
end
def test_create_system_form_submitted
ApplicationController.wiki = WikiServiceWithNoPersistence.new
assert !ApplicationController.wiki.setup?
process('create_system', 'password' => 'a_password', 'web_name' => 'My Wiki',
'web_address' => 'my_wiki')
assert_redirected_to :web => 'my_wiki', :controller => 'wiki', :action => 'new',
:id => 'HomePage'
assert ApplicationController.wiki.setup?
assert_equal 'a_password', ApplicationController.wiki.system[:password]
assert_equal 1, ApplicationController.wiki.webs.size
new_web = ApplicationController.wiki.webs['my_wiki']
assert_equal 'My Wiki', new_web.name
assert_equal 'my_wiki', new_web.address
end
def test_create_system_form_submitted_and_wiki_already_initialized
wiki_before = ApplicationController.wiki
assert ApplicationController.wiki.setup?
process 'create_system', 'password' => 'a_password', 'web_name' => 'My Wiki',
'web_address' => 'my_wiki'
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'HomePage'
assert_equal wiki_before, ApplicationController.wiki
# and no new web should be created either
assert_equal 1, ApplicationController.wiki.webs.size
assert_flash_has :error
end
def test_create_system_no_form_and_wiki_already_initialized
assert @wiki.setup?
process('create_system')
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'HomePage'
assert_flash_has :error
end
def test_create_web
@wiki.system[:password] = 'pswd'
process 'create_web', 'system_password' => 'pswd', 'name' => 'Wiki Two', 'address' => 'wiki2'
assert_redirected_to :web => 'wiki2', :action => 'new', :id => 'HomePage'
wiki2 = @wiki.webs['wiki2']
assert wiki2
assert_equal 'Wiki Two', wiki2.name
assert_equal 'wiki2', wiki2.address
end
def test_create_web_default_password
@wiki.system[:password] = nil
process 'create_web', 'system_password' => 'instiki', 'name' => 'Wiki Two', 'address' => 'wiki2'
assert_redirected_to :web => 'wiki2', :action => 'new', :id => 'HomePage'
end
def test_create_web_failed_authentication
@wiki.system[:password] = 'pswd'
process 'create_web', 'system_password' => 'wrong', 'name' => 'Wiki Two', 'address' => 'wiki2'
assert_redirected_to :web => nil, :action => 'index'
assert_nil @wiki.webs['wiki2']
end
def test_create_web_no_form_submitted
@wiki.system[:password] = 'pswd'
process 'create_web'
assert_success
end
def test_edit_web_no_form
process 'edit_web', 'web' => 'wiki1'
# this action simply renders a form
assert_success
end
def test_edit_web_form_submitted
@wiki.system[:password] = 'pswd'
process('edit_web', 'system_password' => 'pswd',
'web' => 'wiki1', 'address' => 'renamed_wiki1', 'name' => 'Renamed Wiki1',
'markup' => 'markdown', 'color' => 'blue', 'additional_style' => 'whatever',
'safe_mode' => 'on', 'password' => 'new_password', 'published' => 'on',
'brackets_only' => 'on', 'count_pages' => 'on', 'allow_uploads' => 'on',
'max_upload_size' => '300')
assert_redirected_to :web => 'renamed_wiki1', :action => 'show', :id => 'HomePage'
assert_equal 'renamed_wiki1', @web.address
assert_equal 'Renamed Wiki1', @web.name
assert_equal :markdown, @web.markup
assert_equal 'blue', @web.color
assert @web.safe_mode
assert_equal 'new_password', @web.password
assert @web.published
assert @web.brackets_only
assert @web.count_pages
assert @web.allow_uploads
assert_equal 300, @web.max_upload_size
end
def test_edit_web_opposite_values
@wiki.system[:password] = 'pswd'
process('edit_web', 'system_password' => 'pswd',
'web' => 'wiki1', 'address' => 'renamed_wiki1', 'name' => 'Renamed Wiki1',
'markup' => 'markdown', 'color' => 'blue', 'additional_style' => 'whatever',
'password' => 'new_password')
# safe_mode, published, brackets_only, count_pages, allow_uploads not set
# and should become false
assert_redirected_to :web => 'renamed_wiki1', :action => 'show', :id => 'HomePage'
assert !@web.safe_mode
assert !@web.published
assert !@web.brackets_only
assert !@web.count_pages
assert !@web.allow_uploads
end
def test_edit_web_wrong_password
process('edit_web', 'system_password' => 'wrong',
'web' => 'wiki1', 'address' => 'renamed_wiki1', 'name' => 'Renamed Wiki1',
'markup' => 'markdown', 'color' => 'blue', 'additional_style' => 'whatever',
'password' => 'new_password')
#returns to the same form
assert_success
assert @response.has_template_object?('error')
end
def test_edit_web_rename_to_already_existing_web_name
@wiki.system[:password] = 'pswd'
@wiki.create_web('Another', 'another')
process('edit_web', 'system_password' => 'pswd',
'web' => 'wiki1', 'address' => 'another', 'name' => 'Renamed Wiki1',
'markup' => 'markdown', 'color' => 'blue', 'additional_style' => 'whatever',
'password' => 'new_password')
#returns to the same form
assert_success
assert @response.has_template_object?('error')
end
def test_edit_web_empty_password
process('edit_web', 'system_password' => '',
'web' => 'wiki1', 'address' => 'renamed_wiki1', 'name' => 'Renamed Wiki1',
'markup' => 'markdown', 'color' => 'blue', 'additional_style' => 'whatever',
'password' => 'new_password')
#returns to the same form
assert_success
assert @response.has_template_object?('error')
end
def test_remove_orphaned_pages
setup_wiki_with_three_pages
@wiki.system[:password] = 'pswd'
orhan_page_linking_to_oak = @wiki.write_page('wiki1', 'Pine',
"Refers to [[Oak]].\n" +
"category: trees",
Time.now, Author.new('TreeHugger', '127.0.0.2'))
r = process('remove_orphaned_pages', 'web' => 'wiki1', 'system_password_orphaned' => 'pswd')
assert_redirected_to :controller => 'wiki', :web => 'wiki1', :action => 'list'
assert_equal [@home, @oak], @web.select.sort,
"Pages are not as expected: #{@web.select.sort.map {|p| p.name}.inspect}"
# Oak is now orphan, second pass should remove it
r = process('remove_orphaned_pages', 'web' => 'wiki1', 'system_password_orphaned' => 'pswd')
assert_redirected_to :controller => 'wiki', :web => 'wiki1', :action => 'list'
assert_equal [@home], @web.select.sort,
"Pages are not as expected: #{@web.select.sort.map {|p| p.name}.inspect}"
# third pass does not destroy HomePage
r = process('remove_orphaned_pages', 'web' => 'wiki1', 'system_password_orphaned' => 'pswd')
assert_redirected_to :action => 'list'
assert_equal [@home], @web.select.sort,
"Pages are not as expected: #{@web.select.sort.map {|p| p.name}.inspect}"
end
def test_remove_orphaned_pages_empty_or_wrong_password
setup_wiki_with_three_pages
@wiki.system[:password] = 'pswd'
process('remove_orphaned_pages', 'web' => 'wiki1')
assert_redirected_to(:controller => 'admin', :action => 'edit_web', :web => 'wiki1')
assert @response.flash[:error]
process('remove_orphaned_pages', 'web' => 'wiki1', 'system_password_orphaned' => 'wrong')
assert_redirected_to(:controller => 'admin', :action => 'edit_web', :web => 'wiki1')
assert @response.flash[:error]
end
end

31
test/functional/application_test.rb
View file

@ -1,31 +0,0 @@
# Unit tests for ApplicationController (the abstract controller class)
require File.dirname(__FILE__) + '/../test_helper'
require 'wiki_controller'
require 'rexml/document'
# Need some concrete class to test the abstract class features
class WikiController; def rescue_action(e) logger.error(e); raise e end; end
class ApplicationTest < Test::Unit::TestCase
def setup
setup_test_wiki
setup_controller_test(WikiController)
end
def tear_down
tear_down_wiki
end
def test_utf8_header
r = process('show', 'web' => 'wiki1', 'id' => 'HomePage')
assert_equal 'text/html; charset=UTF-8', r.headers['Content-Type']
end
def test_connect_to_model_unknown_wiki
r = process('show', 'web' => 'unknown_wiki', 'id' => 'HomePage')
assert_equal 404, r.response_code
end
end

127
test/functional/file_controller_test.rb
View file

@ -1,127 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'file_controller'
require 'fileutils'
# Raise errors beyond the default web-based presentation
class FileController; def rescue_action(e) logger.error(e); raise e end; end
class FileControllerTest < Test::Unit::TestCase
FILE_AREA = RAILS_ROOT + '/storage/test/wiki1'
FileUtils.mkdir_p(FILE_AREA) unless File.directory?(FILE_AREA)
FileUtils.rm(Dir["#{FILE_AREA}/*"])
def setup
setup_test_wiki
setup_controller_test
end
def tear_down
tear_down_wiki
end
def test_file
process 'file', 'web' => 'wiki1', 'id' => 'foo.tgz'
assert_success
assert_rendered_file 'file/file'
end
def test_file_download_text_file
File.open("#{FILE_AREA}/foo.txt", 'wb') { |f| f.write "aaa\nbbb\n" }
r = process 'file', 'web' => 'wiki1', 'id' => 'foo.txt'
assert_success
assert_equal "aaa\nbbb\n", r.binary_content
assert_equal 'text/plain', r.headers['Content-Type']
end
def test_file_download_pdf_file
File.open("#{FILE_AREA}/foo.pdf", 'wb') { |f| f.write "aaa\nbbb\n" }
r = process 'file', 'web' => 'wiki1', 'id' => 'foo.pdf'
assert_success
assert_equal "aaa\nbbb\n", r.binary_content
assert_equal 'application/pdf', r.headers['Content-Type']
end
def test_pic_download_gif
FileUtils.cp("#{RAILS_ROOT}/test/fixtures/rails.gif", FILE_AREA)
r = process 'pic', 'web' => 'wiki1', 'id' => 'rails.gif'
assert_success
assert_equal File.size("#{FILE_AREA}/rails.gif"), r.binary_content.size
end
def test_pic_unknown_pic
r = process 'pic', 'web' => 'wiki1', 'id' => 'non-existant.gif'
assert_success
assert_rendered_file 'file/file'
end
def test_pic_upload_end_to_end
# edit and re-render home page so that it has an "unknown file" link to 'rails-e2e.gif'
@wiki.revise_page('wiki1', 'HomePage', '[[rails-e2e.gif:pic]]', Time.now, 'AnonymousBrave')
assert_equal "<p><span class=\"newWikiWord\">rails-e2e.gif<a href=\"../pic/rails-e2e.gif\">" +
"?</a></span></p>",
@home.display_content
# rails-e2e.gif is unknown to the system, so pic action goes to the file [upload] form
r = process 'pic', 'web' => 'wiki1', 'id' => 'rails-e2e.gif'
assert_success
assert_rendered_file 'file/file'
# User uploads the picture
picture = File.read("#{RAILS_ROOT}/test/fixtures/rails.gif")
r = process 'pic', 'web' => 'wiki1', 'id' => 'rails-e2e.gif', 'file' => StringIO.new(picture)
assert_redirect_url '/'
assert @wiki.file_yard(@web).has_file?('rails-e2e.gif')
assert_equal(picture, File.read("#{RAILS_ROOT}/storage/test/wiki1/rails-e2e.gif"))
# this should refresh the page display content (cached)
assert_equal "<p><img alt=\"rails-e2e.gif\" src=\"../pic/rails-e2e.gif\" /></p>",
@home.display_content
end
def test_pic_upload_end_to_end
# edit and re-render home page so that it has an "unknown file" link to 'rails-e2e.gif'
@wiki.revise_page('wiki1', 'HomePage', '[[instiki-e2e.txt:file]]', Time.now, 'AnonymousBrave')
assert_equal "<p><span class=\"newWikiWord\">instiki-e2e.txt" +
"<a href=\"../file/instiki-e2e.txt\">?</a></span></p>",
@home.display_content
# rails-e2e.gif is unknown to the system, so pic action goes to the file [upload] form
r = process 'file', 'web' => 'wiki1', 'id' => 'instiki-e2e.txt'
assert_success
assert_rendered_file 'file/file'
# User uploads the picture
file = "abcdefgh\n123"
r = process 'file', 'web' => 'wiki1', 'id' => 'instiki-e2e.txt', 'file' => StringIO.new(file)
assert_redirected_to :controller => 'wiki', :action => 'show', :web => 'wiki1', :id => 'HomePage'
assert @wiki.file_yard(@web).has_file?('instiki-e2e.txt')
assert_equal(file, File.read("#{RAILS_ROOT}/storage/test/wiki1/instiki-e2e.txt"))
# this should refresh the page display content (cached)
assert_equal "<p><a class=\"existingWikiWord\" href=\"../file/instiki-e2e.txt\">" +
"instiki-e2e.txt</a></p>",
@home.display_content
end
def test_uploads_blocking
@web.allow_uploads = true
r = process 'file', 'web' => 'wiki1', 'id' => 'filename'
assert_success
@web.allow_uploads = false
r = process 'file', 'web' => 'wiki1', 'id' => 'filename'
assert_equal '403 Forbidden', r.headers['Status']
end
end

53
test/functional/routes_test.rb
View file

@ -1,53 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'action_controller/routing'
class RoutesTest < Test::Unit::TestCase
def test_parse_uri
assert_routing('', :controller => 'wiki', :action => 'index')
assert_routing('x', :controller => 'wiki', :action => 'index', :web => 'x')
assert_routing('x/y', :controller => 'wiki', :web => 'x', :action => 'y')
assert_routing('x/y/z', :controller => 'wiki', :web => 'x', :action => 'y', :id => 'z')
assert_recognizes({:web => 'x', :controller => 'wiki', :action => 'y'}, 'x/y/')
assert_recognizes({:web => 'x', :controller => 'wiki', :action => 'y', :id => 'z'}, 'x/y/z/')
end
def test_parse_uri_interestng_cases
assert_routing('_veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery-long_web_/an_action/HomePage',
:web => '_veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery-long_web_',
:controller => 'wiki',
:action => 'an_action', :id => 'HomePage'
)
assert_recognizes({:controller => 'wiki', :action => 'index'}, '///')
end
def test_parse_uri_liberal_with_pagenames
assert_routing('web/show/%24HOME_PAGE',
:controller => 'wiki', :web => 'web', :action => 'show', :id => '$HOME_PAGE')
assert_routing('web/show/HomePage%3Farg1%3Dvalue1%26arg2%3Dvalue2',
:controller => 'wiki', :web => 'web', :action => 'show',
:id => 'HomePage?arg1=value1&arg2=value2')
assert_routing('web/file/abc.zip',
:web => 'web', :controller => 'file', :action => 'file', :id => 'abc.zip')
assert_routing('web/pic/abc.jpg',
:web => 'web', :controller => 'file', :action => 'pic', :id => 'abc.jpg')
assert_routing('web/import', :web => 'web', :controller => 'file', :action => 'import')
# default option is wiki
assert_recognizes({:controller => 'wiki', :web => 'unknown_path', :action => 'index', },
'unknown_path')
end
def test_cases_broken_by_routes
# assert_routing('web/show/Page+With+Spaces',
# :controller => 'wiki', :web => 'web', :action => 'show', :id => 'Page With Spaces')
# assert_routing('web/show/HomePage%2Fsomething_else',
# :controller => 'wiki', :web => 'web', :action => 'show', :id => 'HomePage/something_else')
end
end

666
test/functional/wiki_controller_test.rb
View file

@ -1,666 +0,0 @@
#!/bin/env ruby -w
# Uncomment the line below to enable pdflatex tests; don't forget to comment them again
# commiting to SVN
# $INSTIKI_TEST_PDFLATEX = true
require File.dirname(__FILE__) + '/../test_helper'
require 'wiki_controller'
require 'rexml/document'
require 'tempfile'
require 'zip/zipfilesystem'
# Raise errors beyond the default web-based presentation
class WikiController; def rescue_action(e) logger.error(e); raise e end; end
class WikiControllerTest < Test::Unit::TestCase
def setup
setup_test_wiki
setup_controller_test
end
def tear_down
tear_down_wiki
end
def test_authenticate
@web.password = 'pswd'
r = process('authenticate', 'web' => 'wiki1', 'password' => 'pswd')
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'HomePage'
assert_equal ['pswd'], r.cookies['web_address']
end
def test_authenticate_wrong_password
@web.password = 'pswd'
r = process('authenticate', 'web' => 'wiki1', 'password' => 'wrong password')
assert_redirected_to :action => 'login', :web => 'wiki1'
assert_nil r.cookies['web_address']
end
def test_authors
setup_wiki_with_three_pages
@wiki.write_page('wiki1', 'BreakSortingOrder',
"This page breaks the accidentally correct sorting order of authors",
Time.now, Author.new('BreakingTheOrder', '127.0.0.2'))
r = process('authors', 'web' => 'wiki1')
assert_success
assert_equal ['AnAuthor', 'BreakingTheOrder', 'Guest', 'TreeHugger'],
r.template_objects['authors']
end
def test_cancel_edit
setup_wiki_with_three_pages
@oak.lock(Time.now, 'Locky')
assert @oak.locked?(Time.now)
r = process('cancel_edit', 'web' => 'wiki1', 'id' => 'Oak')
assert_redirected_to :action => 'show', :id => 'Oak'
assert !@oak.locked?(Time.now)
end
def test_edit
r = process 'edit', 'web' => 'wiki1', 'id' => 'HomePage'
assert_success
assert_equal @wiki.read_page('wiki1', 'HomePage'), r.template_objects['page']
end
def test_edit_page_locked_page
@home.lock(Time.now, 'Locky')
process 'edit', 'web' => 'wiki1', 'id' => 'HomePage'
assert_redirected_to :action => 'locked'
end
def test_edit_page_break_lock
@home.lock(Time.now, 'Locky')
process 'edit', 'web' => 'wiki1', 'id' => 'HomePage', 'break_lock' => 'y'
assert_success
assert @home.locked?(Time.now)
end
def test_edit_unknown_page
process 'edit', 'web' => 'wiki1', 'id' => 'UnknownPage', 'break_lock' => 'y'
assert_redirected_to :controller => 'wiki', :action => 'show', :web => 'wiki1',
:id => 'HomePage'
end
def test_edit_page_with_special_symbols
@wiki.write_page('wiki1', 'With : Special /> symbols',
'This page has special symbols in the name',
Time.now, Author.new('Special', '127.0.0.3'))
r = process 'edit', 'web' => 'wiki1', 'id' => 'With : Special /> symbols'
assert_success
xml = REXML::Document.new(r.body)
form = REXML::XPath.first(xml, '//form')
assert_equal '/wiki1/save/With+%3A+Special+%2F%3E+symbols', form.attributes['action']
end
def test_export_html
setup_wiki_with_three_pages
r = process 'export_html', 'web' => 'wiki1'
assert_success
assert_equal 'application/zip', r.headers['Content-Type']
assert_match /attachment; filename="wiki1-html-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.zip"/,
r.headers['Content-Disposition']
content = r.binary_content
assert_equal 'PK', content[0..1], 'Content is not a zip file'
assert_equal :export, r.template_objects['link_mode']
# Tempfile doesn't know how to open files with binary flag, hence the two-step process
Tempfile.open('instiki_export_file') { |f| @tempfile_path = f.path }
begin
File.open(@tempfile_path, 'wb') { |f| f.write(content); @exported_file = f.path }
Zip::ZipFile.open(@exported_file) do |zip|
assert_equal %w(Elephant.html HomePage.html Oak.html index.html), zip.dir.entries('.').sort
assert_match /.*<html .*All about elephants.*<\/html>/,
zip.file.read('Elephant.html').gsub(/\s+/, ' ')
assert_match /.*<html .*All about oak.*<\/html>/,
zip.file.read('Oak.html').gsub(/\s+/, ' ')
assert_match /.*<html .*First revision of the.*HomePage.*end.*<\/html>/,
zip.file.read('HomePage.html').gsub(/\s+/, ' ')
assert_equal '<html><head><META HTTP-EQUIV="Refresh" CONTENT="0;URL=HomePage.html"></head></html> ', zip.file.read('index.html').gsub(/\s+/, ' ')
end
ensure
File.delete(@tempfile_path) if File.exist?(@tempfile_path)
end
end
def test_export_html_no_layout
setup_wiki_with_three_pages
r = process 'export_html', 'web' => 'wiki1', 'layout' => 'no'
assert_success
assert_equal 'application/zip', r.headers['Content-Type']
assert_match /attachment; filename="wiki1-html-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.zip"/,
r.headers['Content-Disposition']
content = r.binary_content
assert_equal 'PK', content[0..1], 'Content is not a zip file'
assert_equal :export, r.template_objects['link_mode']
end
def test_export_markup
r = process 'export_markup', 'web' => 'wiki1'
assert_success
assert_equal 'application/zip', r.headers['Content-Type']
assert_match /attachment; filename="wiki1-textile-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.zip"/,
r.headers['Content-Disposition']
content = r.binary_content
assert_equal 'PK', content[0..1], 'Content is not a zip file'
end
if ENV['INSTIKI_TEST_LATEX'] or defined? $INSTIKI_TEST_PDFLATEX
def test_export_pdf
r = process 'export_pdf', 'web' => 'wiki1'
assert_success
assert_equal 'application/pdf', r.headers['Content-Type']
assert_match /attachment; filename="wiki1-tex-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.pdf"/,
r.headers['Content-Disposition']
content = r.binary_content
assert_equal '%PDF', content[0..3]
assert_equal "EOF\n", content[-4..-1]
end
else
puts 'Warning: tests involving pdflatex are very slow, therefore they are disabled by default.'
puts ' Set environment variable INSTIKI_TEST_PDFLATEX or global Ruby variable'
puts ' $INSTIKI_TEST_PDFLATEX to enable them.'
end
def test_export_tex
setup_wiki_with_three_pages
r = process 'export_tex', 'web' => 'wiki1'
assert_success
assert_equal 'application/octet-stream', r.headers['Content-Type']
assert_match /attachment; filename="wiki1-tex-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.tex"/,
r.headers['Content-Disposition']
content = r.binary_content
assert_equal '\documentclass', content[0..13], 'Content is not a TeX file'
end
def test_feeds
process('feeds', 'web' => 'wiki1')
end
def test_index
process('index')
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'HomePage'
end
def test_index_multiple_webs
@wiki.create_web('Test Wiki 2', 'wiki2')
process('index')
assert_redirected_to :action => 'web_list'
end
def test_index_multiple_webs_web_explicit
@wiki.create_web('Test Wiki 2', 'wiki2')
process('index', 'web' => 'wiki2')
assert_redirected_to :web => 'wiki2', :action => 'show', :id => 'HomePage'
end
def test_index_wiki_not_initialized
ApplicationController.wiki = WikiServiceWithNoPersistence.new
process('index')
assert_redirected_to :controller => 'admin', :action => 'create_system'
end
def test_list
setup_wiki_with_three_pages
r = process('list', 'web' => 'wiki1')
assert_equal ['animals', 'trees'], r.template_objects['categories']
assert_nil r.template_objects['category']
assert_equal [@elephant, @home, @oak], r.template_objects['pages_in_category']
end
def test_locked
@home.lock(Time.now, 'Locky')
r = process('locked', 'web' => 'wiki1', 'id' => 'HomePage')
assert_success
assert_equal @home, r.template_objects['page']
end
def test_login
r = process 'login', 'web' => 'wiki1'
assert_success
# this action goes straight to the templates
end
def test_new
r = process('new', 'id' => 'NewPage', 'web' => 'wiki1')
assert_success
assert_equal 'AnonymousCoward', r.template_objects['author']
assert_equal 'NewPage', r.template_objects['page_name']
end
if ENV['INSTIKI_TEST_LATEX'] or defined? $INSTIKI_TEST_PDFLATEX
def test_pdf
assert RedClothForTex.available?, 'Cannot do test_pdf when pdflatex is not available'
r = process('pdf', 'web' => 'wiki1', 'id' => 'HomePage')
assert_success
content = r.binary_content
assert_equal '%PDF', content[0..3]
assert_equal "EOF\n", content[-4..-1]
assert_equal 'application/pdf', r.headers['Content-Type']
assert_match /attachment; filename="HomePage-wiki1-\d\d\d\d-\d\d-\d\d-\d\d-\d\d-\d\d.pdf"/,
r.headers['Content-Disposition']
end
end
def test_print
r = process('print', 'web' => 'wiki1', 'id' => 'HomePage')
assert_success
assert_equal :show, r.template_objects['link_mode']
end
def test_published
@web.published = true
r = process('published', 'web' => 'wiki1', 'id' => 'HomePage')
assert_success
assert_equal @home, r.template_objects['page']
end
def test_published_web_not_published
@web.published = false
r = process('published', 'web' => 'wiki1', 'id' => 'HomePage')
assert_redirected_to :action => 'show', :id => 'HomePage'
end
def test_recently_revised
r = process('recently_revised', 'web' => 'wiki1')
assert_success
assert_equal [], r.template_objects['categories']
assert_nil r.template_objects['category']
assert_equal [@home], r.template_objects['pages_in_category']
assert_equal 'the web', r.template_objects['set_name']
end
def test_recently_revised_with_categorized_page
page2 = @wiki.write_page('wiki1', 'Page2',
"Page2 contents.\n" +
"category: categorized",
Time.now, Author.new('AnotherAuthor', '127.0.0.2'))
r = process('recently_revised', 'web' => 'wiki1')
assert_success
assert_equal ['categorized'], r.template_objects['categories']
# no category is specified in params
assert_nil r.template_objects['category']
assert_equal [@home, page2], r.template_objects['pages_in_category'],
"Pages are not as expected: " +
r.template_objects['pages_in_category'].map {|p| p.name}.inspect
assert_equal 'the web', r.template_objects['set_name']
end
def test_recently_revised_with_categorized_page_multiple_categories
setup_wiki_with_three_pages
r = process('recently_revised', 'web' => 'wiki1')
assert_success
assert_equal ['animals', 'trees'], r.template_objects['categories']
# no category is specified in params
assert_nil r.template_objects['category']
assert_equal [@elephant, @home, @oak], r.template_objects['pages_in_category'],
"Pages are not as expected: " +
r.template_objects['pages_in_category'].map {|p| p.name}.inspect
assert_equal 'the web', r.template_objects['set_name']
end
def test_recently_revised_with_specified_category
setup_wiki_with_three_pages
r = process('recently_revised', 'web' => 'wiki1', 'category' => 'animals')
assert_success
assert_equal ['animals', 'trees'], r.template_objects['categories']
# no category is specified in params
assert_equal 'animals', r.template_objects['category']
assert_equal [@elephant], r.template_objects['pages_in_category']
assert_equal "category 'animals'", r.template_objects['set_name']
end
def test_revision
r = process 'revision', 'web' => 'wiki1', 'id' => 'HomePage', 'rev' => '0'
assert_success
assert_equal @home, r.template_objects['page']
assert_equal @home.revisions[0], r.template_objects['revision']
end
def test_rollback
# rollback shows a form where a revision can be edited.
# its assigns the same as or revision
r = process 'rollback', 'web' => 'wiki1', 'id' => 'HomePage', 'rev' => '0'
assert_success
assert_equal @home, r.template_objects['page']
assert_equal @home.revisions[0], r.template_objects['revision']
end
def test_rss_with_content
setup_wiki_with_three_pages
r = process 'rss_with_content', 'web' => 'wiki1'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal [@home, @oak, @elephant], pages,
"Pages are not as expected: #{pages.map {|p| p.name}.inspect}"
assert !r.template_objects['hide_description']
end
def test_rss_with_content_when_blocked
setup_wiki_with_three_pages
@web.password = 'aaa'
@web.published = false
r = process 'rss_with_content', 'web' => 'wiki1'
assert_equal 403, r.response_code
end
def test_rss_with_headlines
setup_wiki_with_three_pages
@title_with_spaces = @wiki.write_page('wiki1', 'Title With Spaces',
'About spaces', 1.hour.ago, Author.new('TreeHugger', '127.0.0.2'))
@request.host = 'localhost'
@request.port = 8080
r = process 'rss_with_headlines', 'web' => 'wiki1'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal [@home, @oak, @elephant, @title_with_spaces], pages,
"Pages are not as expected: #{pages.map {|p| p.name}.inspect}"
assert r.template_objects['hide_description']
xml = REXML::Document.new(r.body)
expected_page_links =
['http://localhost:8080/wiki1/show/HomePage',
'http://localhost:8080/wiki1/show/Oak',
'http://localhost:8080/wiki1/show/Elephant',
'http://localhost:8080/wiki1/show/Title+With+Spaces']
assert_template_xpath_match '/rss/channel/link',
'http://localhost:8080/wiki1/show/HomePage'
assert_template_xpath_match '/rss/channel/item/guid', expected_page_links
assert_template_xpath_match '/rss/channel/item/link', expected_page_links
end
def test_rss_switch_links_to_published
setup_wiki_with_three_pages
@web.password = 'aaa'
@web.published = true
@request.host = 'foo.bar.info'
@request.port = 80
r = process 'rss_with_headlines', 'web' => 'wiki1'
assert_success
xml = REXML::Document.new(r.body)
expected_page_links =
['http://foo.bar.info/wiki1/published/HomePage',
'http://foo.bar.info/wiki1/published/Oak',
'http://foo.bar.info/wiki1/published/Elephant']
assert_template_xpath_match '/rss/channel/link',
'http://foo.bar.info/wiki1/published/HomePage'
assert_template_xpath_match '/rss/channel/item/guid', expected_page_links
assert_template_xpath_match '/rss/channel/item/link', expected_page_links
end
def test_rss_with_params
setup_wiki_with_30_pages
r = process 'rss_with_headlines', 'web' => 'wiki1'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 15, pages.size, 15
r = process 'rss_with_headlines', 'web' => 'wiki1', 'limit' => '5'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 5, pages.size
r = process 'rss_with_headlines', 'web' => 'wiki1', 'limit' => '25'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 25, pages.size
r = process 'rss_with_headlines', 'web' => 'wiki1', 'limit' => 'all'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 31, pages.size
r = process 'rss_with_headlines', 'web' => 'wiki1', 'start' => '1976-10-16'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 16, pages.size
r = process 'rss_with_headlines', 'web' => 'wiki1', 'end' => '1976-10-16'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 15, pages.size
r = process 'rss_with_headlines', 'web' => 'wiki1', 'start' => '1976-10-01', 'end' => '1976-10-06'
assert_success
pages = r.template_objects['pages_by_revision']
assert_equal 5, pages.size
end
def test_rss_title_with_ampersand
# was ticket:143
setup_wiki_with_three_pages
@wiki.write_page('wiki1', 'Title&With&Ampersands',
'About spaces', 1.hour.ago, Author.new('NitPicker', '127.0.0.3'))
r = process 'rss_with_headlines', 'web' => 'wiki1'
assert r.body.include?('<title>Home Page</title>')
assert r.body.include?('<title>Title&amp;With&amp;Ampersands</title>')
end
def test_rss_timestamp
setup_wiki_with_three_pages
new_page = @wiki.write_page('wiki1', 'PageCreatedAtTheBeginningOfCtime',
'Created on 1 Jan 1970 at 0:00:00 Z', Time.at(0), Author.new('NitPicker', '127.0.0.3'))
r = process 'rss_with_headlines', 'web' => 'wiki1'
assert_template_xpath_match '/rss/channel/item/pubDate[4]', "Thu, 01 Jan 1970 00:00:00 Z"
end
def test_save
r = process 'save', 'web' => 'wiki1', 'id' => 'NewPage', 'content' => 'Contents of a new page',
'author' => 'AuthorOfNewPage'
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'NewPage'
assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
new_page = @wiki.read_page('wiki1', 'NewPage')
assert_equal 'Contents of a new page', new_page.content
assert_equal 'AuthorOfNewPage', new_page.author
end
def test_save_new_revision_of_existing_page
@home.lock(Time.now, 'Batman')
r = process 'save', 'web' => 'wiki1', 'id' => 'HomePage', 'content' => 'Revised HomePage',
'author' => 'Batman'
assert_redirected_to :web => 'wiki1', :action => 'show', :id => 'HomePage'
assert_equal ['Batman'], r.cookies['author'].value
home_page = @wiki.read_page('wiki1', 'HomePage')
assert_equal [home_page], @web.pages.values
assert_equal 2, home_page.revisions.size
assert_equal 'Revised HomePage', home_page.content
assert_equal 'Batman', home_page.author
assert !home_page.locked?(Time.now)
end
def test_save_new_revision_identical_to_last
revisions_before = @home.revisions.size
@home.lock(Time.now, 'AnAuthor')
r = process 'save', {'web' => 'wiki1', 'id' => 'HomePage',
'content' => @home.revisions.last.content.dup,
'author' => 'SomeOtherAuthor'}, {:return_to => '/wiki1/show/HomePage'}
assert_redirected_to :action => 'edit', :web => 'wiki1', :id => 'HomePage'
assert_flash_has :error
assert r.flash[:error].kind_of?(Instiki::ValidationError)
revisions_after = @home.revisions.size
assert_equal revisions_before, revisions_after
assert !@home.locked?(Time.now), 'HomePage should be unlocked if an edit was unsuccessful'
end
def test_search
setup_wiki_with_three_pages
r = process 'search', 'web' => 'wiki1', 'query' => '\s[A-Z]ak'
assert_redirected_to :action => 'show', :id => 'Oak'
end
def test_search_multiple_results
setup_wiki_with_three_pages
r = process 'search', 'web' => 'wiki1', 'query' => 'All about'
assert_success
assert_equal 'All about', r.template_objects['query']
assert_equal [@elephant, @oak], r.template_objects['results']
assert_equal [], r.template_objects['title_results']
end
def test_search_by_content_and_title
setup_wiki_with_three_pages
r = process 'search', 'web' => 'wiki1', 'query' => '(Oak|Elephant)'
assert_success
assert_equal '(Oak|Elephant)', r.template_objects['query']
assert_equal [@elephant, @oak], r.template_objects['results']
assert_equal [@elephant, @oak], r.template_objects['title_results']
end
def test_search_zero_results
setup_wiki_with_three_pages
r = process 'search', 'web' => 'wiki1', 'query' => 'non-existant text'
assert_success
assert_equal [], r.template_objects['results']
assert_equal [], r.template_objects['title_results']
end
def test_show_page
r = process('show', 'id' => 'HomePage', 'web' => 'wiki1')
assert_success
assert_match /First revision of the <a.*HomePage.*<\/a> end/, r.body
end
def test_show_page_with_multiple_revisions
@wiki.write_page('wiki1', 'HomePage', 'Second revision of the HomePage end', Time.now,
Author.new('AnotherAuthor', '127.0.0.2'))
r = process('show', 'id' => 'HomePage', 'web' => 'wiki1')
assert_success
assert_match /Second revision of the <a.*HomePage.*<\/a> end/, r.body
end
def test_show_page_nonexistant_page
process('show', 'id' => 'UnknownPage', 'web' => 'wiki1')
assert_redirected_to :web => 'wiki1', :action => 'new', :id => 'UnknownPage'
end
def test_show_no_page
r = process('show', 'id' => '', 'web' => 'wiki1')
assert_equal 404, r.response_code
r = process('show', 'web' => 'wiki1')
assert_equal 404, r.response_code
end
def test_tex
r = process('tex', 'web' => 'wiki1', 'id' => 'HomePage')
assert_success
assert_equal "\\documentclass[12pt,titlepage]{article}\n\n\\usepackage[danish]{babel} " +
"%danske tekster\n\\usepackage[OT1]{fontenc} %rigtige danske bogstaver...\n" +
"\\usepackage{a4}\n\\usepackage{graphicx}\n\\usepackage{ucs}\n\\usepackage[utf8x]" +
"{inputenc}\n\\input epsf \n\n%----------------------------------------------------" +
"---------------\n\n\\begin{document}\n\n\\sloppy\n\n%-----------------------------" +
"--------------------------------------\n\n\\section*{HomePage}\n\nFirst revision of " +
"the HomePage end\n\n\\end{document}", r.body
end
def test_web_list
another_wiki = @wiki.create_web('Another Wiki', 'another_wiki')
r = process('web_list')
assert_success
assert_equal [another_wiki, @web], r.template_objects['webs']
end
end

129
test/test_helper.rb
View file

@ -1,129 +0,0 @@
ENV['RAILS_ENV'] = 'test'
require File.expand_path(File.dirname(__FILE__) + '/../config/environment')
require 'application'
require 'test/unit'
require 'breakpoint'
require 'action_controller/test_process'
# Uncomment this variable to have assert_success check that response bodies are valid XML
$validate_xml_in_assert_success = true
# Convenient setup method for Test::Unit::TestCase
class Test::Unit::TestCase
private
def setup_controller_test(controller_class = nil, host = nil)
if controller_class
@controller = controller_class.new
elsif self.class.to_s =~ /^(\w+Controller)Test$/
@controller = Object::const_get($1).new
else
raise "Cannot derive the name of controller under test from class name #{self.class}"
end
@request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
@request.host = host || 'localhost'
return @request, @response
end
# Wiki fixture for tests
def setup_test_wiki
@wiki = ApplicationController.wiki = WikiServiceWithNoPersistence.new
@web = @wiki.create_web('Test Wiki 1', 'wiki1')
@home = @wiki.write_page('wiki1', 'HomePage', 'First revision of the HomePage end', Time.now,
Author.new('AnAuthor', '127.0.0.1'))
end
def setup_wiki_with_three_pages
@oak = @wiki.write_page('wiki1', 'Oak',
"All about oak.\n" +
"category: trees",
5.minutes.ago, Author.new('TreeHugger', '127.0.0.2'))
@elephant = @wiki.write_page('wiki1', 'Elephant',
"All about elephants.\n" +
"category: animals",
10.minutes.ago, Author.new('Guest', '127.0.0.2'))
end
def setup_wiki_with_30_pages
(1..30).each { |i|
@wiki.write_page('wiki1', "page#{i}", "Test page #{i}\ncategory: test",
Time.local(1976, 10, i, 12, 00, 00), Author.new('Dema', '127.0.0.2'))
}
end
def tear_down_wiki
ApplicationController.wiki = nil
end
end
class WikiServiceWithNoPersistence
include AbstractWikiService
def initialize
init_wiki_service
end
def storage_path
RAILS_ROOT + '/storage/test/'
end
end
# This module is to be included in unit tests that involve matching chunks.
# It provides a easy way to test whether a chunk matches a particular string
# and any the values of any fields that should be set after a match.
class ContentStub < String
include ChunkManager
def initialize(str)
super
init_chunk_manager
end
def page_link(*); end
end
module ChunkMatch
# Asserts a number of tests for the given type and text.
def match(chunk_type, test_text, expected_chunk_state)
if chunk_type.respond_to? :pattern
assert_match(chunk_type.pattern, test_text)
end
content = ContentStub.new(test_text)
chunk_type.apply_to(content)
# Test if requested parts are correct.
expected_chunk_state.each_pair do |a_method, expected_value|
assert content.chunks.last.kind_of?(chunk_type)
assert_respond_to(content.chunks.last, a_method)
assert_equal(expected_value, content.chunks.last.send(a_method.to_sym),
"Wrong #{a_method} value")
end
end
# Asserts that test_text doesn't match the chunk_type
def no_match(chunk_type, test_text)
if chunk_type.respond_to? :pattern
assert_no_match(chunk_type.pattern, test_text)
end
end
end
if defined? $validate_xml_in_assert_success and $validate_xml_in_assert_success == true
module Test
module Unit
module Assertions
unless method_defined? :__assert_success_before_ovverride_by_instiki
alias :__assert_success_before_ovverride_by_instiki :assert_success
end
def assert_success
__assert_success_before_ovverride_by_instiki
if @response.body.kind_of?(Proc) then # it's a file download, not an HTML content
else assert_nothing_raised(@response.body) { REXML::Document.new(@response.body) } end
end
end
end
end
end

22
test/unit/chunks/category_test.rb
View file

@ -1,22 +0,0 @@
#!/bin/env ruby
require File.dirname(__FILE__) + '/../../test_helper'
require 'chunks/category'
class CategoryTest < Test::Unit::TestCase
include ChunkMatch
def test_single_category
match(Category, 'category: test', :list => ['test'], :hidden => nil)
match(Category, 'category : chunk test ', :list => ['chunk test'], :hidden => nil)
match(Category, ':category: test', :list => ['test'], :hidden => ':')
end
def test_multiple_categories
match(Category, 'category: test, multiple', :list => ['test', 'multiple'], :hidden => nil)
match(Category, 'category : chunk test , multi category,regression test case ',
:list => ['chunk test','multi category','regression test case'], :hidden => nil
)
end
end

15
test/unit/chunks/nowiki_test.rb
View file

@ -1,15 +0,0 @@
#!/bin/env ruby
require File.dirname(__FILE__) + '/../../test_helper'
require 'chunks/nowiki'
class NoWikiTest < Test::Unit::TestCase
include ChunkMatch
def test_simple_nowiki
match(NoWiki, 'This sentence contains <nowiki>[[raw text]]</nowiki>. Do not touch!',
:plain_text => '[[raw text]]'
)
end
end

98
test/unit/chunks/wiki_test.rb
View file

@ -1,98 +0,0 @@
#!/bin/env ruby
require File.dirname(__FILE__) + '/../../test_helper'
require 'chunks/wiki'
class WikiTest < Test::Unit::TestCase
include ChunkMatch
def test_simple
match(WikiChunk::Word, 'This is a WikiWord okay?', :page_name => 'WikiWord')
end
def test_escaped
# escape is only implemented in WikiChunk::Word
match(WikiChunk::Word, 'Do not link to an \EscapedWord',
:page_name => 'EscapedWord', :escaped_text => 'EscapedWord'
)
end
def test_simple_brackets
match(WikiChunk::Link, 'This is a [[bracketted link]]', :page_name => 'bracketted link')
end
def test_void_brackets
# double brackets woith only spaces inside are not a WikiLink
no_match(WikiChunk::Link, "This [[ ]] are [[]] no [[ \t ]] links")
end
def test_brackets_strip_spaces
match(WikiChunk::Link,
"This is a [[Sperberg-McQueen \t ]] link with trailing spaces to strip",
:page_name => 'Sperberg-McQueen')
match(WikiChunk::Link,
"This is a [[ \t Sperberg-McQueen]] link with leading spaces to strip",
:page_name => 'Sperberg-McQueen')
match(WikiChunk::Link,
'This is a [[ Sperberg-McQueen ]] link with spaces around it to strip',
:page_name => 'Sperberg-McQueen')
match(WikiChunk::Link,
'This is a [[ Sperberg McQueen ]] link with spaces inside and around it',
:page_name => 'Sperberg McQueen')
end
def test_complex_brackets
match(WikiChunk::Link, 'This is a tricky link [[Sperberg-McQueen]]',
:page_name => 'Sperberg-McQueen')
end
def test_include_chunk_pattern
content = 'This is a [[!include pagename]] and [[!include WikiWord]] but [[blah]]'
recognized_includes = content.scan(Include.pattern).collect { |m| m[0] }
assert_equal %w(pagename WikiWord), recognized_includes
end
def test_textile_link
textile_link = ContentStub.new('"Here is a special link":SpecialLink')
WikiChunk::Word.apply_to(textile_link)
assert_equal '"Here is a special link":SpecialLink', textile_link
assert textile_link.chunks.empty?
end
def test_file_types
# only link
assert_link_parsed_as 'only text', 'only text', :show, '[[only text]]'
# link and text
assert_link_parsed_as 'page name', 'link text', :show, '[[page name|link text]]'
# link and type (file)
assert_link_parsed_as 'foo.tar.gz', 'foo.tar.gz', :file, '[[foo.tar.gz:file]]'
# link and type (pic)
assert_link_parsed_as 'foo.tar.gz', 'foo.tar.gz', :pic, '[[foo.tar.gz:pic]]'
# link, text and type
assert_link_parsed_as 'foo.tar.gz', 'FooTar', :file, '[[foo.tar.gz|FooTar:file]]'
# NEGATIVE TEST CASES
# empty page name
assert_link_parsed_as '|link text?', '|link text?', :file, '[[|link text?:file]]'
# empty link text
assert_link_parsed_as 'page name?|', 'page name?|', :file, '[[page name?|:file]]'
# empty link type
assert_link_parsed_as 'page name', 'link?:', :show, '[[page name|link?:]]'
# unknown link type
assert_link_parsed_as 'page name:create_system', 'page name:create_system', :show,
'[[page name:create_system]]'
end
def assert_link_parsed_as(expected_page_name, expected_link_text, expected_link_type, link)
link_to_file = ContentStub.new(link)
WikiChunk::Link.apply_to(link_to_file)
chunk = link_to_file.chunks.last
assert chunk
assert_equal expected_page_name, chunk.page_name
assert_equal expected_link_text, chunk.link_text
assert_equal expected_link_type, chunk.link_type
end
end

92
test/unit/diff_test.rb
View file

@ -1,92 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'diff'
include Diff
class DiffTest < Test::Unit::TestCase
def test_init
assert_nothing_raised {
s = SequenceMatcher.new('private Thread currentThread;',
'private volatile Thread currentThread;') { |x| x == ' ' }
}
end
def test_matching_blocks
s = SequenceMatcher.new 'abxcd', 'abcd'
assert_equal [[0, 0, 2], [3, 2, 2], [5, 4, 0]], s.get_matching_blocks
end
def test_ratio
s = SequenceMatcher.new 'abcd', 'bcde'
assert_equal 0.75, s.ratio, 0.001
assert_equal 0.75, s.quick_ratio, 0.001
assert_equal 1.0, s.real_quick_ratio, 0.001
end
def test_longest_match
s = SequenceMatcher.new(' abcd', 'abcd abcd')
assert_equal [0, 4, 5], s.find_longest_match(0, 5, 0, 9)
end
def test_opcodes
s = SequenceMatcher.new('qabxcd', 'abycdf')
assert_equal(
[
[:delete, 0, 1, 0, 0],
[:equal, 1, 3, 0, 2],
[:replace, 3, 4, 2, 3],
[:equal, 4, 6, 3, 5],
[:insert, 6, 6, 5, 6]
],
s.get_opcodes)
end
def test_count_leading
assert_equal 3, Diff.count_leading(' abc', ' ')
end
def test_html2list
a = "here is the original text"
assert_equal(
['here ', 'is ', 'the ', 'original ', 'text'],
HTMLDiff.html2list(a))
end
def test_html_diff
a = 'this was the original string'
b = 'this is the super string'
assert_equal('this <del class="diffmod">was </del>' +
'<ins class="diffmod">is </ins>the ' +
'<del class="diffmod">original </del>' +
'<ins class="diffmod">super </ins>string',
HTMLDiff.diff(a, b))
end
def test_html_diff_with_multiple_paragraphs
a = "<p>this was the original string</p>"
b = "<p>this is</p>\r\n<p>the super string</p>\r\n<p>around the world</p>"
assert_equal(
"<p>this <del class=\"diffmod\">was </del>" +
"<ins class=\"diffmod\">is</ins></p>\r\n<p>the " +
"<del class=\"diffmod\">original </del>" +
"<ins class=\"diffmod\">super </ins>string</p>\r\n" +
"<p><ins class=\"diffins\">around the world</ins></p>",
HTMLDiff.diff(a, b)
)
end
# FIXME this test fails (ticket #67, http://dev.instiki.org/ticket/67)
def test_html_diff_preserves_endlines_in_pre
a = "<pre>\na\nb\nc\n</pre>"
b = ''
assert_equal(
"<pre>\n<del class=\"diffdel\">a\nb\nc\n</del></pre>",
HTMLDiff.diff(a, b))
end
end

70
test/unit/file_yard_test.rb
View file

@ -1,70 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'fileutils'
require 'file_yard'
require 'stringio'
class FileYardTest < Test::Unit::TestCase
def setup
FileUtils.mkdir_p(file_path)
FileUtils.rm(Dir["#{file_path}/*"])
@yard = FileYard.new(file_path, 100)
end
def test_check_upload_size
assert_nothing_raised { @yard.check_upload_size(100.kilobytes) }
assert_raises(Instiki::ValidationError) { @yard.check_upload_size(100.kilobytes + 1) }
end
def test_files
assert_equal [], @yard.files
# FileYard gets the list of files from directory in the constructor
@yard.upload_file('aaa', StringIO.new('file contents'))
assert_equal ["#{file_path}/aaa"], Dir["#{file_path}/*"]
assert_equal ['aaa'], @yard.files
assert @yard.has_file?('aaa')
assert_equal 'file contents', File.read(@yard.file_path('aaa'))
end
def test_file_path
assert_equal "#{file_path}/abcd", @yard.file_path('abcd')
end
def test_size_limit
@yard = FileYard.new(file_path, 1)
one_kilobyte_string = "a" * 1.kilobyte
# as StringIO
assert_nothing_raised {
@yard.upload_file('acceptable_file', StringIO.new(one_kilobyte_string))
}
assert_raises(Instiki::ValidationError) {
@yard.upload_file('one_byte_too_long', StringIO.new(one_kilobyte_string + 'a'))
}
# as Tempfile
require 'tempfile'
Tempfile.open('acceptable_file') do |f|
f.write(one_kilobyte_string)
assert_nothing_raised {
@yard.upload_file('acceptable_file', f)
}
end
Tempfile.open('one_byte_too_long') do |f|
f.write(one_kilobyte_string + 'a')
assert_nothing_raised {
@yard.upload_file('one_byte_too_long_2', f)
}
end
end
def file_path
"#{RAILS_ROOT}/storage/test/instiki"
end
end

89
test/unit/page_test.rb
View file

@ -1,89 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'web'
require 'page'
class PageTest < Test::Unit::TestCase
class MockWeb < Web
def initialize() super(nil, 'test','test') end
def [](wiki_word) %w( MyWay ThatWay SmartEngine ).include?(wiki_word) end
def refresh_pages_with_references(name) end
end
def setup
@page = Page.new(MockWeb.new, "FirstPage")
@page.revise("HisWay would be MyWay in kinda ThatWay in HisWay though MyWay \\OverThere -- see SmartEngine in that SmartEngineGUI",
Time.local(2004, 4, 4, 16, 50),
"DavidHeinemeierHansson")
end
def test_lock
assert !@page.locked?(Time.local(2004, 4, 4, 16, 50))
@page.lock(Time.local(2004, 4, 4, 16, 30), "DavidHeinemeierHansson")
assert @page.locked?(Time.local(2004, 4, 4, 16, 50))
assert !@page.locked?(Time.local(2004, 4, 4, 17, 1))
@page.unlock
assert !@page.locked?(Time.local(2004, 4, 4, 16, 50))
end
def test_lock_duration
@page.lock(Time.local(2004, 4, 4, 16, 30), "DavidHeinemeierHansson")
assert_equal 15, @page.lock_duration(Time.local(2004, 4, 4, 16, 45))
end
def test_plain_name
assert_equal "First Page", @page.plain_name
end
def test_revise
@page.revise('HisWay would be MyWay in kinda lame', Time.local(2004, 4, 4, 16, 55), 'MarianneSyhler')
assert_equal 2, @page.revisions.length, 'Should have two revisions'
assert_equal 'MarianneSyhler', @page.author, 'Mary should be the author now'
assert_equal 'DavidHeinemeierHansson', @page.revisions.first.author, 'David was the first author'
end
def test_revise_continous_revision
@page.revise('HisWay would be MyWay in kinda lame', Time.local(2004, 4, 4, 16, 55), 'MarianneSyhler')
assert_equal 2, @page.revisions.length
@page.revise('HisWay would be MyWay in kinda update', Time.local(2004, 4, 4, 16, 57), 'MarianneSyhler')
assert_equal 2, @page.revisions.length
assert_equal 'HisWay would be MyWay in kinda update', @page.revisions.last.content
assert_equal Time.local(2004, 4, 4, 16, 57), @page.revisions.last.created_at
@page.revise('HisWay would be MyWay in the house', Time.local(2004, 4, 4, 16, 58), 'DavidHeinemeierHansson')
assert_equal 3, @page.revisions.length
assert_equal 'HisWay would be MyWay in the house', @page.revisions.last.content
@page.revise('HisWay would be MyWay in my way', Time.local(2004, 4, 4, 17, 30), 'DavidHeinemeierHansson')
assert_equal 4, @page.revisions.length
end
def test_revise_content_unchanged
last_revision_before = @page.revisions.last
revisions_number_before = @page.revisions.size
assert_raises(Instiki::ValidationError) {
@page.revise(@page.revisions.last.content.dup, Time.now, 'AlexeyVerkhovsky')
}
assert_same last_revision_before, @page.revisions.last
assert_equal revisions_number_before, @page.revisions.size
end
def test_rollback
@page.revise("spot two", Time.now, "David")
@page.revise("spot three", Time.now + 2000, "David")
assert_equal 3, @page.revisions.length, "Should have three revisions"
@page.rollback(1, Time.now)
assert_equal "spot two", @page.content
end
end

69
test/unit/redcloth_for_tex_test.rb
View file

@ -1,69 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'redcloth_for_tex'
class RedClothForTexTest < Test::Unit::TestCase
def test_basics
assert_equal '{\bf First Page}', RedClothForTex.new("*First Page*").to_tex
assert_equal '{\em First Page}', RedClothForTex.new("_First Page_").to_tex
assert_equal "\\begin{itemize}\n\t\\item A\n\t\t\\item B\n\t\t\\item C\n\t\\end{itemize}", RedClothForTex.new("* A\n* B\n* C").to_tex
end
def test_blocks
assert_equal '\section*{hello}', RedClothForTex.new("h1. hello").to_tex
assert_equal '\subsection*{hello}', RedClothForTex.new("h2. hello").to_tex
end
def test_table_of_contents
source = <<EOL
* [[A]]
** [[B]]
** [[C]]
* D
** [[E]]
*** F
EOL
expected_result = <<EOL
\\pagebreak
\\section{A}
Abe
\\subsection{B}
Babe
\\subsection{C}
\\pagebreak
\\section{D}
\\subsection{E}
\\subsubsection{F}
EOL
expected_result.chop!
assert_equal(expected_result, table_of_contents(source, 'A' => 'Abe', 'B' => 'Babe'))
end
def test_entities
assert_equal "Beck \\& Fowler are 100\\% cool", RedClothForTex.new("Beck & Fowler are 100% cool").to_tex
end
def test_bracket_links
assert_equal "such a Horrible Day, but I won't be Made Useless", RedClothForTex.new("such a [[Horrible Day]], but I won't be [[Made Useless]]").to_tex
end
def test_footnotes_on_abbreviations
assert_equal(
"such a Horrible Day\\footnote{1}, but I won't be Made Useless",
RedClothForTex.new("such a [[Horrible Day]][1], but I won't be [[Made Useless]]").to_tex
)
end
def test_subsection_depth
assert_equal "\\subsubsection*{Hello}", RedClothForTex.new("h4. Hello").to_tex
end
end

335
test/unit/revision_test.rb
View file

@ -1,335 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'web'
require 'revision'
require 'fileutils'
class RevisionTest < Test::Unit::TestCase
def setup
setup_test_wiki
@web.markup = :textile
@page = @wiki.read_page('wiki1', 'HomePage')
['MyWay', 'SmartEngine', 'ThatWay'].each do |page|
@wiki.write_page('wiki1', page, page, Time.now, 'Me')
end
@wiki.write_page('wiki1','NoWikiWord', 'hey you', Time.now, 'Me')
@revision = Revision.new(@page, 1,
'HisWay would be MyWay in kinda ThatWay in HisWay though MyWay \OverThere -- ' +
'see SmartEngine in that SmartEngineGUI',
Time.local(2004, 4, 4, 16, 50), 'DavidHeinemeierHansson')
end
def test_wiki_words
assert_equal %w( HisWay MyWay SmartEngine SmartEngineGUI ThatWay ), @revision.wiki_words.sort
@wiki.write_page('wiki1', 'NoWikiWord', 'hey you', Time.now, 'Me')
assert_equal [], @wiki.read_page('wiki1', 'NoWikiWord').wiki_words
end
def test_existing_pages
assert_equal %w( MyWay SmartEngine ThatWay ), @revision.existing_pages.sort
end
def test_unexisting_pages
assert_equal %w( HisWay SmartEngineGUI ), @revision.unexisting_pages.sort
end
def test_content_with_wiki_links
assert_equal '<p><span class="newWikiWord">His Way<a href="../show/HisWay">?</a></span> ' +
'would be <a class="existingWikiWord" href="../show/MyWay">My Way</a> in kinda ' +
'<a class="existingWikiWord" href="../show/ThatWay">That Way</a> in ' +
'<span class="newWikiWord">His Way<a href="../show/HisWay">?</a></span> ' +
'though <a class="existingWikiWord" href="../show/MyWay">My Way</a> OverThere&#8212;see ' +
'<a class="existingWikiWord" href="../show/SmartEngine">Smart Engine</a> in that ' +
'<span class="newWikiWord">Smart Engine GUI' +
'<a href="../show/SmartEngineGUI">?</a></span></p>',
@revision.display_content
end
def test_markdown
@web.markup = :markdown
assert_markup_parsed_as(
%{<h1>My Headline</h1>\n\n<p>that <span class="newWikiWord">} +
%{Smart Engine GUI<a href="../show/SmartEngineGUI">?</a></span></p>},
"My Headline\n===========\n\nthat SmartEngineGUI")
code_block = [
'This is a code block:',
'',
' def a_method(arg)',
' return ThatWay',
'',
'Nice!'
].join("\n")
assert_markup_parsed_as(
%{<p>This is a code block:</p>\n\n<pre><code>def a_method(arg)\n} +
%{return ThatWay\n</code></pre>\n\n<p>Nice!</p>},
code_block)
end
def test_markdown_hyperlink_with_slash
# in response to a bug, see http://dev.instiki.org/attachment/ticket/177
@web.markup = :markdown
assert_markup_parsed_as(
'<p><a href="http://example/with/slash">text</a></p>',
'[text](http://example/with/slash)')
end
def test_mixed_formatting
textile_and_markdown = [
'Markdown heading',
'================',
'',
'h2. Textile heading',
'',
'*some* **text** _with_ -styles-',
'',
'* list 1',
'* list 2'
].join("\n")
@web.markup = :markdown
assert_markup_parsed_as(
"<h1>Markdown heading</h1>\n\n" +
"<p>h2. Textile heading</p>\n\n" +
"<p><em>some</em> <strong>text</strong> <em>with</em> -styles-</p>\n\n" +
"<ul>\n<li>list 1</li>\n<li>list 2</li>\n</ul>",
textile_and_markdown)
@web.markup = :textile
assert_markup_parsed_as(
"<p>Markdown heading<br />================</p>\n\n\n\t<h2>Textile heading</h2>" +
"\n\n\n\t<p><strong>some</strong> <b>text</b> <em>with</em> <del>styles</del></p>" +
"\n\n\n\t<ul>\n\t<li>list 1</li>\n\t\t<li>list 2</li>\n\t</ul>",
textile_and_markdown)
@web.markup = :mixed
assert_markup_parsed_as(
"<h1>Markdown heading</h1>\n\n\n\t<h2>Textile heading</h2>\n\n\n\t" +
"<p><strong>some</strong> <b>text</b> <em>with</em> <del>styles</del></p>\n\n\n\t" +
"<ul>\n\t<li>list 1</li>\n\t\t<li>list 2</li>\n\t</ul>",
textile_and_markdown)
end
def test_rdoc
@web.markup = :rdoc
@revision = Revision.new(@page, 1, '+hello+ that SmartEngineGUI',
Time.local(2004, 4, 4, 16, 50), 'DavidHeinemeierHansson')
assert_equal "<tt>hello</tt> that <span class=\"newWikiWord\">Smart Engine GUI" +
"<a href=\"../show/SmartEngineGUI\">?</a></span>\n\n", @revision.display_content
end
def test_content_with_auto_links
assert_markup_parsed_as(
'<p><a href="http://www.loudthinking.com/">http://www.loudthinking.com/</a> ' +
'points to <a class="existingWikiWord" href="../show/ThatWay">That Way</a> from ' +
'<a href="mailto:david@loudthinking.com">david@loudthinking.com</a></p>',
'http://www.loudthinking.com/ points to ThatWay from david@loudthinking.com')
end
def test_content_with_aliased_links
assert_markup_parsed_as(
'<p>Would a <a class="existingWikiWord" href="../show/SmartEngine">clever motor' +
'</a> go by any other name?</p>',
'Would a [[SmartEngine|clever motor]] go by any other name?')
end
def test_content_with_wikiword_in_em
assert_markup_parsed_as(
'<p><em>should we go <a class="existingWikiWord" href="../show/ThatWay">' +
'That Way</a> or <span class="newWikiWord">This Way<a href="../show/ThisWay">?</a>' +
'</span> </em></p>',
'_should we go ThatWay or ThisWay _')
end
def test_content_with_wikiword_in_tag
assert_markup_parsed_as(
'<p>That is some <em style="WikiWord">Stylish Emphasis</em></p>',
'That is some <em style="WikiWord">Stylish Emphasis</em>')
end
def test_content_with_escaped_wikiword
# there should be no wiki link
assert_markup_parsed_as('<p>WikiWord</p>', '\WikiWord')
end
def test_content_with_pre_blocks
assert_markup_parsed_as(
'<p>A <code>class SmartEngine end</code> would not mark up <pre>CodeBlocks</pre></p>',
'A <code>class SmartEngine end</code> would not mark up <pre>CodeBlocks</pre>')
end
def test_content_with_autolink_in_parentheses
assert_markup_parsed_as(
'<p>The <span class="caps">W3C</span> body (<a href="http://www.w3c.org">' +
'http://www.w3c.org</a>) sets web standards</p>',
'The W3C body (http://www.w3c.org) sets web standards')
end
def test_content_with_link_in_parentheses
assert_markup_parsed_as(
'<p>(<a href="http://wiki.org/wiki.cgi?WhatIsWiki">What is a wiki?</a>)</p>',
'("What is a wiki?":http://wiki.org/wiki.cgi?WhatIsWiki)')
end
def test_content_with_image_link
assert_markup_parsed_as(
'<p>This <img src="http://hobix.com/sample.jpg" alt="" /> is a Textile image link.</p>',
'This !http://hobix.com/sample.jpg! is a Textile image link.')
end
def test_content_with_inlined_img_tag
assert_markup_parsed_as(
'<p>This <img src="http://hobix.com/sample.jpg" alt="" /> is an inline image link.</p>',
'This <img src="http://hobix.com/sample.jpg" alt="" /> is an inline image link.')
assert_markup_parsed_as(
'<p>This <IMG SRC="http://hobix.com/sample.jpg" alt=""> is an inline image link.</p>',
'This <IMG SRC="http://hobix.com/sample.jpg" alt=""> is an inline image link.')
end
def test_nowiki_tag
assert_markup_parsed_as(
'<p>Do not mark up [[this text]] or http://www.thislink.com.</p>',
'Do not mark up <nowiki>[[this text]]</nowiki> ' +
'or <nowiki>http://www.thislink.com</nowiki>.')
end
def test_multiline_nowiki_tag
assert_markup_parsed_as(
"<p>Do not mark \n up [[this text]] \nand http://this.url.com but markup " +
'<span class="newWikiWord">this<a href="../show/this">?</a></span></p>',
"Do not <nowiki>mark \n up [[this text]] \n" +
"and http://this.url.com </nowiki> but markup [[this]]")
end
def test_content_with_bracketted_wiki_word
@web.brackets_only = true
assert_markup_parsed_as(
'<p>This is a WikiWord and a tricky name <span class="newWikiWord">' +
'Sperberg-McQueen<a href="../show/Sperberg-McQueen">?</a></span>.</p>',
'This is a WikiWord and a tricky name [[Sperberg-McQueen]].')
end
def test_content_for_export
assert_equal '<p><span class="newWikiWord">His Way</span> would be ' +
'<a class="existingWikiWord" href="MyWay.html">My Way</a> in kinda ' +
'<a class="existingWikiWord" href="ThatWay.html">That Way</a> in ' +
'<span class="newWikiWord">His Way</span> though ' +
'<a class="existingWikiWord" href="MyWay.html">My Way</a> OverThere&#8212;see ' +
'<a class="existingWikiWord" href="SmartEngine.html">Smart Engine</a> in that ' +
'<span class="newWikiWord">Smart Engine GUI</span></p>',
@revision.display_content_for_export
end
def test_double_replacing
@revision.content = "VersionHistory\r\n\r\ncry VersionHistory"
assert_equal '<p><span class="newWikiWord">Version History' +
"<a href=\"../show/VersionHistory\">?</a></span></p>\n\n\n\t<p>cry " +
'<span class="newWikiWord">Version History<a href="../show/VersionHistory">?</a>' +
'</span></p>',
@revision.display_content
@revision.clear_display_cache
@revision.content = "f\r\nVersionHistory\r\n\r\ncry VersionHistory"
assert_equal "<p>f<br /><span class=\"newWikiWord\">Version History" +
"<a href=\"../show/VersionHistory\">?</a></span></p>\n\n\n\t<p>cry " +
"<span class=\"newWikiWord\">Version History<a href=\"../show/VersionHistory\">?</a>" +
"</span></p>",
@revision.display_content
end
def test_difficult_wiki_words
@revision.content = "[[It's just awesome GUI!]]"
assert_equal "<p><span class=\"newWikiWord\">It's just awesome GUI!" +
"<a href=\"../show/It%27s+just+awesome+GUI%21\">?</a></span></p>",
@revision.display_content
end
def test_revisions_diff
@page.revisions = [
Revision.new(@page, 0, 'What a blue and lovely morning',
Time.local(2004, 4, 4, 16, 50), 'DavidHeinemeierHansson'),
Revision.new(@page, 1, 'What a red and lovely morning today',
Time.local(2004, 4, 4, 16, 50), 'DavidHeinemeierHansson')
]
assert_equal "<p>What a <del class=\"diffmod\">blue </del><ins class=\"diffmod\">red " +
"</ins>and lovely <del class=\"diffmod\">morning</del><ins class=\"diffmod\">morning " +
"today</ins></p>", @page.revisions.last.display_diff
end
def test_link_to_file
assert_markup_parsed_as(
'<p><span class="newWikiWord">doc.pdf<a href="../file/doc.pdf">?</a></span></p>',
'[[doc.pdf:file]]')
end
def test_link_to_pic
FileUtils.mkdir_p "#{RAILS_ROOT}/storage/test/wiki1"
FileUtils.rm(Dir["#{RAILS_ROOT}/storage/test/wiki1/*"])
@wiki.file_yard(@web).upload_file('square.jpg', StringIO.new(''))
assert_markup_parsed_as(
'<p><img alt="Square" src="../pic/square.jpg" /></p>',
'[[square.jpg|Square:pic]]')
assert_markup_parsed_as(
'<p><img alt="square.jpg" src="../pic/square.jpg" /></p>',
'[[square.jpg:pic]]')
end
def test_link_to_non_existant_pic
assert_markup_parsed_as(
'<p><span class="newWikiWord">NonExistant<a href="../pic/NonExistant.jpg">?</a>' +
'</span></p>',
'[[NonExistant.jpg|NonExistant:pic]]')
assert_markup_parsed_as(
'<p><span class="newWikiWord">NonExistant.jpg<a href="../pic/NonExistant.jpg">?</a>' +
'</span></p>',
'[[NonExistant.jpg:pic]]')
end
def test_wiki_link_with_colon
assert_markup_parsed_as(
'<p><span class="newWikiWord">With:Colon<a href="../show/With%3AColon">?</a></span></p>',
'[[With:Colon]]')
end
# TODO Remove the leading underscores from this test when upgrading to RedCloth 3.0.1;
# also add a test for the "Unhappy Face" problem (another interesting RedCloth bug)
def test_list_with_tildas
list_with_tildas = <<-EOL
* "a":~b
* c~ d
EOL
assert_markup_parsed_as(
"<ul>\n\t<li><a href=\"~b\">a</a></li>\n\t\t<li>c~ d</li>\n\t</ul>",
list_with_tildas)
end
def test_textile_image_in_mixed_wiki
@web.markup = :mixed
assert_markup_parsed_as(
"<p><img src=\"http://google.com\" alt=\"\" />\nss</p>",
"!http://google.com!\r\nss")
end
def assert_markup_parsed_as(expected_output, input)
revision = Revision.new(@page, 1, input, Time.local(2004, 4, 4, 16, 50), 'AnAuthor')
assert_equal expected_output, revision.display_content, 'Textile output not as expected'
end
end

217
test/unit/uri_test.rb
View file

@ -1,217 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'chunks/uri'
class URITest < Test::Unit::TestCase
include ChunkMatch
def test_non_matches
assert_conversion_does_not_apply(URIChunk, 'There is no URI here')
assert_conversion_does_not_apply(URIChunk,
'One gemstone is the garnet:reddish in colour, like ruby')
end
def test_simple_uri
# Simplest case
match(URIChunk, 'http://www.example.com',
:scheme =>'http', :host =>'www.example.com', :path => nil,
:link_text => 'http://www.example.com'
)
# With trailing slash
match(URIChunk, 'http://www.example.com/',
:scheme =>'http', :host =>'www.example.com', :path => '/',
:link_text => 'http://www.example.com/'
)
# Without http://
match(URIChunk, 'www.example.com',
:scheme =>'http', :host =>'www.example.com', :link_text => 'www.example.com'
)
# two parts
match(URIChunk, 'example.com',
:scheme =>'http',:host =>'example.com', :link_text => 'example.com'
)
# "unusual" base domain (was a bug in an early version)
match(URIChunk, 'http://example.com.au/',
:scheme =>'http', :host =>'example.com.au', :link_text => 'http://example.com.au/'
)
# "unusual" base domain without http://
match(URIChunk, 'example.com.au',
:scheme =>'http', :host =>'example.com.au', :link_text => 'example.com.au'
)
# Another "unusual" base domain
match(URIChunk, 'http://www.example.co.uk/',
:scheme =>'http', :host =>'www.example.co.uk',
:link_text => 'http://www.example.co.uk/'
)
match(URIChunk, 'example.co.uk',
:scheme =>'http', :host =>'example.co.uk', :link_text => 'example.co.uk'
)
# With some path at the end
match(URIChunk, 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation',
:scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
:link_text => 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation'
)
# With some path at the end, and withot http:// prefix
match(URIChunk, 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
:scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
:link_text => 'moinmoin.wikiwikiweb.de/HelpOnNavigation'
)
# With a port number
match(URIChunk, 'http://www.example.com:80',
:scheme =>'http', :host =>'www.example.com', :port => '80', :path => nil,
:link_text => 'http://www.example.com:80')
# With a port number and a path
match(URIChunk, 'http://www.example.com.tw:80/HelpOnNavigation',
:scheme =>'http', :host =>'www.example.com.tw', :port => '80', :path => '/HelpOnNavigation',
:link_text => 'http://www.example.com.tw:80/HelpOnNavigation')
# With a query
match(URIChunk, 'http://www.example.com.tw:80/HelpOnNavigation?arg=val',
:scheme =>'http', :host =>'www.example.com.tw', :port => '80', :path => '/HelpOnNavigation',
:query => 'arg=val',
:link_text => 'http://www.example.com.tw:80/HelpOnNavigation?arg=val')
# Query with two arguments
match(URIChunk, 'http://www.example.com.tw:80/HelpOnNavigation?arg=val&arg2=val2',
:scheme =>'http', :host =>'www.example.com.tw', :port => '80', :path => '/HelpOnNavigation',
:query => 'arg=val&arg2=val2',
:link_text => 'http://www.example.com.tw:80/HelpOnNavigation?arg=val&arg2=val2')
# HTTPS
match(URIChunk, 'https://www.example.com',
:scheme =>'https', :host =>'www.example.com', :port => nil, :path => nil, :query => nil,
:link_text => 'https://www.example.com')
# FTP
match(URIChunk, 'ftp://www.example.com',
:scheme =>'ftp', :host =>'www.example.com', :port => nil, :path => nil, :query => nil,
:link_text => 'ftp://www.example.com')
# mailto
match(URIChunk, 'mailto:jdoe123@example.com',
:scheme =>'mailto', :host =>'example.com', :port => nil, :path => nil, :query => nil,
:user => 'jdoe123', :link_text => 'mailto:jdoe123@example.com')
# something nonexistant
match(URIChunk, 'foobar://www.example.com',
:scheme =>'foobar', :host =>'www.example.com', :port => nil, :path => nil, :query => nil,
:link_text => 'foobar://www.example.com')
# Soap opera (the most complex case imaginable... well, not really, there should be more evil)
match(URIChunk, 'http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2',
:scheme =>'http', :host =>'www.example.com.tw', :port => '80',
:path => '/~jdoe123/Help%20Me%20', :query => 'arg=val&arg2=val2',
:link_text => 'http://www.example.com.tw:80/~jdoe123/Help%20Me%20?arg=val&arg2=val2')
# from 0.9 bug reports
match(URIChunk, 'http://www2.pos.to/~tosh/ruby/rdtool/en/doc/rd-draft.html',
:scheme =>'http', :host => 'www2.pos.to',
:path => '/~tosh/ruby/rdtool/en/doc/rd-draft.html')
match(URIChunk, 'http://support.microsoft.com/default.aspx?scid=kb;en-us;234562',
:scheme =>'http', :host => 'support.microsoft.com', :path => '/default.aspx',
:query => 'scid=kb;en-us;234562')
end
def test_email_uri
match(URIChunk, 'mail@example.com',
:user => 'mail', :host => 'example.com', :link_text => 'mail@example.com'
)
end
def test_non_email
# The @ is part of the normal text, but 'example.com' is marked up.
match(URIChunk, 'Not an email: @example.com', :user => nil, :uri => 'http://example.com')
end
def test_textile_image
assert_conversion_does_not_apply(URIChunk,
'This !http://hobix.com/sample.jpg! is a Textile image link.')
end
def test_textile_link
assert_conversion_does_not_apply(URIChunk,
'This "hobix (hobix)":http://hobix.com/sample.jpg is a Textile link.')
# just to be sure ...
match(URIChunk, 'This http://hobix.com/sample.jpg should match',
:link_text => 'http://hobix.com/sample.jpg')
end
def test_inline_html
assert_conversion_does_not_apply(URIChunk, '<IMG SRC="http://hobix.com/sample.jpg">')
assert_conversion_does_not_apply(URIChunk, "<img src='http://hobix.com/sample.jpg'/>")
end
def test_non_uri
# "so" is a valid country code; "libproxy.so" is a valid url
match(URIChunk, 'libproxy.so', :link_text => 'libproxy.so')
assert_conversion_does_not_apply URIChunk, 'httpd.conf'
assert_conversion_does_not_apply URIChunk, 'ld.so.conf'
assert_conversion_does_not_apply URIChunk, 'index.jpeg'
assert_conversion_does_not_apply URIChunk, 'index.jpg'
assert_conversion_does_not_apply URIChunk, 'file.txt'
assert_conversion_does_not_apply URIChunk, 'file.doc'
assert_conversion_does_not_apply URIChunk, 'file.pdf'
assert_conversion_does_not_apply URIChunk, 'file.png'
assert_conversion_does_not_apply URIChunk, 'file.ps'
end
def test_uri_in_text
match(URIChunk, 'Go to: http://www.example.com/', :host => 'www.example.com', :path =>'/')
match(URIChunk, 'http://www.example.com/ is a link.', :host => 'www.example.com')
match(URIChunk,
'Email david@loudthinking.com',
:scheme =>'mailto', :user =>'david', :host =>'loudthinking.com')
# check that trailing punctuation is not included in the hostname
match(URIChunk, 'Hey dude, http://fake.link.com.', :scheme => 'http', :host => 'fake.link.com')
# this is a textile link, no match please.
assert_conversion_does_not_apply(URIChunk, '"link":http://fake.link.com.')
end
def test_uri_in_parentheses
match(URIChunk, 'URI (http://brackets.com.de) in brackets', :host => 'brackets.com.de')
match(URIChunk, 'because (as shown at research.net) the results', :host => 'research.net')
match(URIChunk,
'A wiki (http://wiki.org/wiki.cgi?WhatIsWiki) page',
:scheme => 'http', :host => 'wiki.org', :path => '/wiki.cgi', :query => 'WhatIsWiki'
)
end
def test_uri_list_item
match(
URIChunk,
'* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis',
:path => '/~mail2minh/SonyEricssonP80xPlatform.sis'
)
end
def test_interesting_uri_with__comma
# Counter-intuitively, this URL matches, but the query part includes the trailing comma.
# It has no way to know that the query does not include the comma.
match(
URIChunk,
"This text contains a URL http://someplace.org:8080/~person/stuff.cgi?arg=val, doesn't it?",
:scheme => 'http', :host => 'someplace.org', :port => '8080', :path => '/~person/stuff.cgi',
:query => 'arg=val,')
end
def test_local_urls
# normal
match(LocalURIChunk, 'http://perforce:8001/toto.html',
:scheme => 'http', :host => 'perforce',
:port => '8001', :link_text => 'http://perforce:8001/toto.html')
# in parentheses
match(LocalURIChunk, 'URI (http://localhost:2500) in brackets',
:host => 'localhost', :port => '2500')
match(LocalURIChunk, 'because (as shown at http://perforce:8001) the results',
:host => 'perforce', :port => '8001')
match(LocalURIChunk,
'A wiki (http://localhost:2500/wiki.cgi?WhatIsWiki) page',
:scheme => 'http', :host => 'localhost', :path => '/wiki.cgi',
:port => '2500', :query => 'WhatIsWiki')
end
def assert_conversion_does_not_apply(chunk_type, str)
processed_str = ContentStub.new(str.dup)
chunk_type.apply_to(processed_str)
assert_equal(str, processed_str)
end
end

165
test/unit/web_test.rb
View file

@ -1,165 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'wiki_service'
class WebTest < Test::Unit::TestCase
def setup
@web = Web.new nil, 'Instiki', 'instiki'
end
def test_wiki_word_linking
@web.add_page('SecondPage', 'Yo, yo. Have you EverBeenHated',
Time.now, 'DavidHeinemeierHansson')
assert_equal('<p>Yo, yo. Have you <span class="newWikiWord">Ever Been Hated' +
'<a href="../show/EverBeenHated">?</a></span></p>',
@web.pages["SecondPage"].display_content)
@web.add_page('EverBeenHated', 'Yo, yo. Have you EverBeenHated', Time.now,
'DavidHeinemeierHansson')
assert_equal('<p>Yo, yo. Have you <a class="existingWikiWord" ' +
'href="../show/EverBeenHated">Ever Been Hated</a></p>',
@web.pages['SecondPage'].display_content)
end
def test_pages_by_revision
add_sample_pages
assert_equal 'EverBeenHated', @web.select.by_revision.first.name
end
def test_pages_by_match
add_sample_pages
assert_equal 2, @web.select { |page| page.content =~ /me/i }.length
assert_equal 1, @web.select { |page| page.content =~ /Who/i }.length
assert_equal 0, @web.select { |page| page.content =~ /none/i }.length
end
def test_references
add_sample_pages
assert_equal 1, @web.select.pages_that_reference('EverBeenHated').length
assert_equal 0, @web.select.pages_that_reference('EverBeenInLove').length
end
def test_delete
add_sample_pages
assert_equal 2, @web.pages.length
@web.remove_pages([ @web.pages['EverBeenInLove'] ])
assert_equal 1, @web.pages.length
end
def test_make_link
add_sample_pages
existing_page_wiki_url =
'<a class="existingWikiWord" href="../show/EverBeenInLove">Ever Been In Love</a>'
existing_page_published_url =
'<a class="existingWikiWord" href="../published/EverBeenInLove">Ever Been In Love</a>'
existing_page_static_url =
'<a class="existingWikiWord" href="EverBeenInLove.html">Ever Been In Love</a>'
new_page_wiki_url =
'<span class="newWikiWord">Unknown Word<a href="../show/UnknownWord">?</a></span>'
new_page_published_url =
new_page_static_url =
'<span class="newWikiWord">Unknown Word</span>'
# no options
assert_equal existing_page_wiki_url, @web.make_link('EverBeenInLove')
# :mode => :export
assert_equal existing_page_static_url, @web.make_link('EverBeenInLove', nil, :mode => :export)
# :mode => :publish
assert_equal existing_page_published_url,
@web.make_link('EverBeenInLove', nil, :mode => :publish)
# new page, no options
assert_equal new_page_wiki_url, @web.make_link('UnknownWord')
# new page, :mode => :export
assert_equal new_page_static_url, @web.make_link('UnknownWord', nil, :mode => :export)
# new page, :mode => :publish
assert_equal new_page_published_url, @web.make_link('UnknownWord', nil, :mode => :publish)
# Escaping special characters in the name
assert_equal(
'<span class="newWikiWord">Smith &amp; Wesson<a href="../show/Smith+%26+Wesson">?</a></span>',
@web.make_link('Smith & Wesson'))
# optionally using text as the link text
assert_equal(
existing_page_published_url.sub(/>Ever Been In Love</, ">Haven't you ever been in love?<"),
@web.make_link('EverBeenInLove', "Haven't you ever been in love?", :mode => :publish))
end
def test_initialize
wiki_stub = Object.new
web = Web.new(wiki_stub, 'Wiki2', 'wiki2', '123')
assert_equal wiki_stub, web.wiki
assert_equal 'Wiki2', web.name
assert_equal 'wiki2', web.address
assert_equal '123', web.password
# new web should be set for maximum features enabled
assert_equal :textile, web.markup
assert_equal '008B26', web.color
assert !web.safe_mode
assert_equal({}, web.pages)
assert web.allow_uploads
assert_equal wiki_stub, web.wiki
assert_nil web.additional_style
assert !web.published
assert !web.brackets_only
assert !web.count_pages
assert web.allow_uploads
assert_equal 100, web.max_upload_size
end
def test_initialize_invalid_name
wiki_stub = Object.new
assert_raises(Instiki::ValidationError) {
Web.new(wiki_stub, 'Wiki2', "wiki\234", '123')
}
end
def test_new_page_linked_from_mother_page
# this was a bug in revision 204
home = @web.add_page('HomePage', 'This page refers to AnotherPage',
Time.local(2004, 4, 4, 16, 50), 'Alexey Verkhovsky')
@web.add_page('AnotherPage', 'This is \AnotherPage',
Time.local(2004, 4, 4, 16, 51), 'Alexey Verkhovsky')
assert_equal [home], @web.select.pages_that_link_to('AnotherPage')
end
def test_orphaned_pages
add_sample_pages
home = @web.add_page('HomePage',
'This is a home page, it should not be an orphan',
Time.local(2004, 4, 4, 16, 50), 'AlexeyVerkhovsky')
author = @web.add_page('AlexeyVerkhovsky',
'This is an author page, it should not be an orphan',
Time.local(2004, 4, 4, 16, 50), 'AlexeyVerkhovsky')
self_linked = @web.add_page('SelfLinked',
'I am me SelfLinked and link to EverBeenInLove',
Time.local(2004, 4, 4, 16, 50), 'AnonymousCoward')
# page that links to itself, and nobody else links to it must be an orphan
assert_equal ['EverBeenHated', 'SelfLinked'],
@web.select.orphaned_pages.collect{ |page| page.name }.sort
end
private
def add_sample_pages
@in_love = @web.add_page('EverBeenInLove', 'Who am I me',
Time.local(2004, 4, 4, 16, 50), 'DavidHeinemeierHansson')
@hated = @web.add_page('EverBeenHated', 'I am me EverBeenHated',
Time.local(2004, 4, 4, 16, 51), 'DavidHeinemeierHansson')
end
end

129
test/unit/wiki_service_test.rb
View file

@ -1,129 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'wiki_service'
require 'fileutils'
class WikiServiceTest < Test::Unit::TestCase
# Clean the test storage directory before the run
unless defined? @@storage_cleaned
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/*.command_log'])
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/*.snapshot'])
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/*.tex'])
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/*.zip'])
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/*.pdf'])
FileUtils.rm(Dir[RAILS_ROOT + '/storage/test/instiki/*'])
@@cleaned_storage = true
WikiService.instance.setup('pswd', 'Wiki', 'wiki')
end
def setup
@s = WikiService.instance
@s.create_web 'Instiki', 'instiki'
@web = @s.webs['instiki']
end
def teardown
@s.delete_web 'instiki'
end
def test_read_write_page
@s.write_page 'instiki', 'FirstPage', "Electric shocks, I love 'em",
Time.now, 'DavidHeinemeierHansson'
assert_equal "Electric shocks, I love 'em", @s.read_page('instiki', 'FirstPage').content
end
def test_read_only_operations
@s.write_page 'instiki', 'TestReadOnlyOperations', 'Read only operations dont change the' +
'state of any object, and therefore should not be logged by Madeleine!',
Time.now, 'AlexeyVerkhovsky'
assert_doesnt_change_state_or_log :authenticate, 'pswd'
assert_doesnt_change_state_or_log :read_page, 'instiki', 'TestReadOnlyOperations'
assert_doesnt_change_state_or_log :setup?
assert_doesnt_change_state_or_log :webs
@s.write_page 'instiki', 'FirstPage', "Electric shocks, I love 'em",
Time.now, 'DavidHeinemeierHansson'
assert_equal "Electric shocks, I love 'em", @s.read_page('instiki', 'FirstPage').content
end
def test_aborted_transaction
@s.write_page 'instiki', 'FirstPage', "Electric shocks, I love 'em",
10.minutes.ago, 'DavidHeinemeierHansson'
assert_doesnt_change_state('revise_page with unchanged content') {
begin
@s.revise_page 'instiki', 'FirstPage', "Electric shocks, I love 'em",
Time.now, 'DavidHeinemeierHansson'
fail 'Expected Instiki::ValidationError not raised'
rescue Instiki::ValidationError
end
}
end
def test_file_yard
file_yard = @s.file_yard(@web)
assert_equal FileYard, file_yard.class
assert_equal(@s.storage_path + '/instiki', file_yard.files_path)
end
def test_edit_web_validations
another_web = @s.create_web 'Another', 'another'
# try to rename instiki web to another (which is the name of an already existing one)
assert_raises(Instiki::ValidationError) {
@s.edit_web('instiki', 'another', @web.name, @web.markup, @web.color, @web.additional_style)
}
assert_raises(Instiki::ValidationError) {
@s.edit_web('nonexistant', 'another', @web.name, @web.markup, @web.color, @web.additional_style)
}
end
# Checks that a method call or a block doesn;t change the persisted state of the wiki
# Usage:
# assert_doesnt_change_state :read_page, 'instiki', 'TestReadOnlyOperations'
# or
# assert_doesnt_change_state {|wiki| wiki.webs}
def assert_doesnt_change_state(method, *args, &block)
_assert_doesnt_change_state(including_command_log = false, method, *args, &block)
end
# Same as assert_doesnt_change_state, but also asserts that no vommand log is generated
def assert_doesnt_change_state_or_log(method, *args, &block)
_assert_doesnt_change_state(including_command_log = true, method, *args, &block)
end
private
def _assert_doesnt_change_state(including_log, method, *args)
WikiService.snapshot
last_snapshot_before = last_snapshot
if block_given?
yield @s
else
@s.send(method, *args)
end
if including_log
command_logs = Dir[RAILS_ROOT + 'storage/test/*.command_log']
assert command_logs.empty?, "Calls to #{method} should not be logged"
end
last_snapshot_after = last_snapshot
assert last_snapshot_before == last_snapshot_after,
'Calls to #{method} should not change the state of any persisted object'
end
def last_snapshot
snapshots = Dir[RAILS_ROOT + '/storage/test/*.snapshot']
assert !snapshots.empty?, "No snapshots found at #{RAILS_ROOT}/storage/test/"
File.read(snapshots.last)
end
end

14
test/unit/wiki_words_test.rb
View file

@ -1,14 +0,0 @@
#!/bin/env ruby -w
require File.dirname(__FILE__) + '/../test_helper'
require 'wiki_words'
class WikiWordsTest < Test::Unit::TestCase
def test_utf8_characters_in_wiki_word
assert_equal "Æåle Øen", WikiWords.separate("ÆåleØen")
assert_equal "ÆÅØle Øen", WikiWords.separate("ÆÅØleØen")
assert_equal "Æe ÅØle Øen", WikiWords.separate("ÆeÅØleØen")
assert_equal "Legetøj", WikiWords.separate("Legetøj")
end
end

361
test/watir/e2e.rb
View file

@ -1,361 +0,0 @@
require 'fileutils'
require 'cgi'
require 'test/unit'
require 'rexml/document'
INSTIKI_ROOT = File.expand_path(File.dirname(__FILE__) + "/../..")
require(File.expand_path(File.dirname(__FILE__) + "/../../config/environment"))
# Use instiki/../watir, if such a directory exists; This can be a CVS HEAD version of Watir.
# Otherwise Watir has to be installed in ruby/lib.
$:.unshift INSTIKI_ROOT + '/../watir' if File.exists?(INSTIKI_ROOT + '/../watir/watir.rb')
require 'watir'
INSTIKI_PORT = 2501
HOME = "http://localhost:#{INSTIKI_PORT}"
class E2EInstikiTest < Test::Unit::TestCase
def startup
@@instiki = InstikiController.start
sleep 5
@@ie = Watir::IE.start(HOME)
setup_web
setup_home_page
@@ie
end
def self.shutdown
@@ie.close if defined? @@ie
@@instiki.stop
end
def ie
if defined? @@ie
@@ie
else
startup
end
end
def setup
ie.goto HOME
ie
end
# Numbers like _00010_ determine the sequence in which the test cases are executed by Test::Unit
# Unfortunately, this sequence is important.
def test_00010_home_page_contents
check_main_menu
check_bottom_menu
check_footnote
end
def test_00020_add_a_page
# Add reference to a non-existant wiki page
enter_markup('HomePage', '[[Another Wiki Page]]')
assert_equal '?', ie.link(:url, url(:show, 'Another Wiki Page')).text
# Edit the first revision of a page
enter_markup('Another Wiki Page', 'First revision of Another Wiki Page, linked from HomePage')
# Check contents of the new page
assert_equal url(:show, 'Another Wiki Page'), ie.url
assert_match /First revision of Another Wiki Page, linked from Home Page/, ie.text
assert_match /Linked from: Home Page/, ie.text
# There must be three links to HomePage - main menu, contents of the page and navigation bar
links_to_homepage = ie.links.to_a.select { |link| link.text == 'Home Page' }
assert_equal 3, links_to_homepage.size
links_to_homepage.each { |link| assert_equal url(:show, 'HomePage'), link.href }
# Check also the "created on ... by ..." footnote
assert_match Regexp.new('Created on ' + date_pattern + ' by Anonymous Coward\?'), ie.text
end
def test_00030_edit_page
enter_markup('TestEditPage', 'Test Edit Page, revision 1')
assert_match /Test Edit Page, revision 1/, ie.text
# subsequent revision by the anonymous author
enter_markup('TestEditPage', 'Test Edit Page, revision 1, altered')
assert_match /Test Edit Page, revision 1, altered/, ie.text
assert_match Regexp.new('Created on ' + date_pattern + ' by Anonymous Coward\?'), ie.text
# revision by a named author
enter_markup('TestEditPage', 'Test Edit Page, revision 2', 'Author')
assert_match /Test Edit Page, revision 2/, ie.text
assert_match Regexp.new('Revised on ' + date_pattern + ' by Author\?'), ie.text
link_to_previous_revision = ie.link(:name, 'to_previous_revision')
assert_equal url(:revision, 'TestEditPage', 0), link_to_previous_revision.href
assert_equal 'Back in time', link_to_previous_revision.text
assert_match /Edit \| Back in time \(1 revisions\) \| See changes/, ie.text
# another anonymous revision
enter_markup('TestEditPage', 'Test Edit Page, revision 3')
assert_match /Test Edit Page, revision 3/, ie.text
assert_match /Edit \| Back in time \(2 revisions\) \| See changes \| Hide changes /, ie.text
end
def test_00040_traversing_revisions
ie.goto url(:revision, 'TestEditPage', 1)
assert_match /Test Edit Page, revision 2/, ie.text
assert_match(Regexp.new(
'Forward in time \(1 more\) \| Back in time \(1 more\) \| ' +
'See current \| See changes \| Hide changes \| Rollback'),
ie.text)
ie.link(:name, 'to_previous_revision').click
assert_match /Test Edit Page, revision 1, altered/, ie.text
assert_match /Forward in time \(2 more\) \| See current \| Rollback/, ie.text
ie.link(:name, 'to_next_revision').click
assert_match /Test Edit Page, revision 2/, ie.text
ie.link(:name, 'to_next_revision').click
assert_match /Test Edit Page, revision 3/, ie.text
end
def test_00050_rollback
ie.goto url(:revision, 'TestEditPage', 1)
assert_match /Test Edit Page, revision 2/, ie.text
ie.link(:name, 'rollback').click
assert_equal url(:rollback, 'TestEditPage', 1), ie.url
assert_equal 'Test Edit Page, revision 2', ie.text_field(:name, 'content').value
ie.text_field(:name, 'content').set('Test Edit Page, revision 2, rolled back')
ie.button(:value, 'Update').click
assert_equal url(:show, 'TestEditPage'), ie.url
assert_match /Test Edit Page, revision 2, rolled back/, ie.text
end
def test_0060_see_changes
ie.goto url(:show, 'TestEditPage')
assert ie.html.include?('<P>Test Edit Page, revision <DEL class=diffmod>2</DEL>' +
'<INS class=diffmod>2, rolled back</INS></P>')
assert_match /Test Edit Page, revision 2, rolled back/, ie.text
ie.link(:text, 'See changes').click
assert_match /Showing changes from revision #1 to #2: Added \| Removed/, ie.text
assert_match /Test Edit Page, revision 22, rolled back/, ie.text
ie.link(:text, 'Hide changes').click
assert_match /Test Edit Page, revision 2, rolled back/, ie.text
end
def test_0070_all_pages
# create a wanted page, and unlink Another Wiki Page from Home Page
# (to see that it doesn't show up in the orphans, regardless)
enter_markup('Another Wiki Page', 'Reference to a NonExistantPage')
ie.link(:text, 'All Pages').click
page_links = ie.links.map { |l| l.text }
expected_page_links = ['Another Wiki Page', 'Home Page', 'Test Edit Page', '?',
'Another Wiki Page', 'Test Edit Page']
assert_equal expected_page_links, page_links[-6..-1]
links_sequence = 'All Pages.*Another Wiki Page.*Home Page.*Test Edit Page.*' +
'Wanted Pages.*Non Existant Page\? wanted by Another Wiki Page.*'+
'Orphaned Pages.*Test Edit Page.*'
assert_match Regexp.new(links_sequence, Regexp::MULTILINE), ie.text
# and before that, we have the tail of the main menu
assert_equal 'Export', page_links[-7]
end
def test_0080_recently_revised
ie.link(:text, 'Recently Revised').click
links = ie.links.map { |l| l.text }
assert_equal ['Another Wiki Page', '?', 'Test Edit Page', '?', 'Home Page', '?'], links[-6..-1]
expected_text =
'Another Wiki Page.*by Anonymous Coward\?.*' +
'Test Edit Page.*by Anonymous Coward\?.*' +
'Home Page.*by Anonymous Coward\?.*'
assert_match Regexp.new(expected_text, Regexp::MULTILINE), ie.text
end
def test_0090_authors
# create a revision of TestEditPage, and a corresponding author page
enter_markup('TestEditPage', '3rd revision of this page', 'Another Author')
ie.link(:afterText, 'Another Author').click
assert_equal url(:new, 'Another Author'), ie.url
enter_markup('Another Author', 'Email me at another_author@foo.bar.com', 'Another Author')
ie.link(:text, 'Authors').click
expected_authors =
'Anonymous Coward\? co- or authored: Another Wiki Page, Home Page, Test Edit Page.*' +
'Another Author co- or authored: Another Author, Test Edit Page.*' +
'Author\? co- or authored: Test Edit Page'
assert_match Regexp.new(expected_authors, Regexp::MULTILINE), ie.text
ie.link(:text, 'Another Author').click
assert_equal url(:show, 'Another Author'), ie.url
ie.back
ie.link(:text, 'Test Edit Page').click
assert_equal url(:show, 'TestEditPage'), ie.url
end
def test_0100_feeds
ie.link(:text, 'Feeds').click
assert_equal url(:rss_with_content), ie.link(:text, 'Full content (RSS 2.0)').href
assert_equal url(:rss_with_headlines), ie.link(:text, 'Headlines (RSS 2.0)').href
ie.link(:text, 'Full content (RSS 2.0)').click
assert_nothing_raised { REXML::Document.new ie.text }
ie.back
ie.link(:text, 'Headlines (RSS 2.0)').click
assert_nothing_raised { REXML::Document.new ie.text }
end
private
def bp
require 'breakpoint'
breakpoint
end
def check_main_menu
assert_equal HOME + '/wiki/list', ie.link(:text, 'All Pages').href
assert_equal HOME + '/wiki/recently_revised', ie.link(:text, 'Recently Revised').href
assert_equal HOME + '/wiki/authors', ie.link(:text, 'Authors').href
assert_equal HOME + '/wiki/feeds', ie.link(:text, 'Feeds').href
assert_equal HOME + '/wiki/export', ie.link(:text, 'Export').href
end
def check_bottom_menu
assert_equal url(:edit, 'HomePage'), ie.link(:text, 'Edit Page').href
assert_equal HOME + '/wiki/edit_web', ie.link(:text, 'Edit Web').href
assert_equal url(:print, 'HomePage'), ie.link(:text, 'Print').href
end
def check_footnote
assert_match /This site is running on Instiki/, ie.text
assert_equal 'http://instiki.org/', ie.link(:text, 'Instiki').href
assert_match /Powered by Ruby on Rails/, ie.text
assert_equal 'http://rubyonrails.com/', ie.link(:text, 'Ruby on Rails').href
end
def date_pattern
'(January|February|March|April|May|June|July|August|September|October|November|December) ' +
'\d\d?, \d\d\d\d \d\d:\d\d'
end
def enter_markup(page, content, author = nil)
ie.goto url(:show, page)
if ie.url == url(:show, page)
ie.link(:name, 'edit').click
assert_equal url(:edit, page), ie.url
else
assert_equal url(:new, page), ie.url
end
ie.text_field(:name, 'content').set(content)
ie.text_field(:name, 'author').set(author || '')
ie.button(:value, 'Submit').click
assert_equal url(:show, page), ie.url
end
def setup_web
assert_equal 'Wiki', ie.textField(:name, 'web_name').value
assert_equal 'wiki', ie.textField(:name, 'web_address').value
assert_equal '', ie.textField(:name, 'password').value
assert_equal '', ie.textField(:name, 'password_check').value
ie.textField(:name, 'password').set('123')
ie.textField(:name, 'password_check').set('123')
ie.button(:value, 'Setup').click
assert_equal url(:new, 'HomePage'), ie.url
end
def setup_home_page
ie.textField(:name, 'content').set('Homepage of a test wiki')
ie.button(:value, 'Submit').click
assert_equal url(:show, 'HomePage'), ie.url
end
def url(operation, page_name = nil, revision = nil)
page_name = CGI.escape(page_name) if page_name
case operation
when :edit, :new, :show, :print, :revision, :rollback
"#{HOME}/wiki/#{operation}/#{page_name}" + (revision ? "?rev=#{revision}" : '')
when :rss_with_content, :rss_with_headlines
"#{HOME}/wiki/#{operation}"
else
raise "Unsupported operation: '#{operation}"
end
end
end
class InstikiController
attr_reader :process_id
def self.start
startup_info = [68].pack('lx64')
process_info = [0, 0, 0, 0].pack('llll')
startup_command =
"ruby #{RAILS_ROOT}/instiki.rb --storage #{prepare_storage} " +
" --port #{INSTIKI_PORT} --environment development"
result = Win32API.new('kernel32.dll', 'CreateProcess', 'pplllllppp', 'L').call(
nil,
startup_command,
0, 0, 1, 0, 0, '.', startup_info, process_info)
# TODO print the error code, or better yet a text message
raise "Failed to start Instiki." if result == 0
process_id = process_info.unpack('llll')[2]
return self.new(process_id)
end
def self.prepare_storage
storage_path = INSTIKI_ROOT + '/storage/e2e'
FileUtils.rm_rf(storage_path) if File.exists? storage_path
FileUtils.mkdir_p(storage_path)
storage_path
end
def initialize(pid)
@process_id = pid
end
def stop
right_to_terminate_process = 1
handle = Win32API.new('kernel32.dll', 'OpenProcess', 'lil', 'l').call(
right_to_terminate_process, 0, @process_id)
Win32API.new('kernel32.dll', 'TerminateProcess', 'll', 'L').call(handle, 0)
end
end
begin
require 'test/unit/ui/console/testrunner'
Test::Unit::UI::Console::TestRunner.new(E2EInstikiTest.suite).start
rescue => e
$stderr.puts 'Unhandled error during test execution'
$stderr.puts e.message
$stderr.puts e.backtrace
ensure
begin
E2EInstikiTest::shutdown
rescue => e
$stderr.puts 'Error during shutdown'
$stderr.puts e.message
$stderr.puts e.backtrace
end
end