moved some tests over

test/unit/chunks/category_test.rb

@@ -0,0 +1,22 @@
+#!/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

test/unit/chunks/nowiki_test.rb

@@ -0,0 +1,15 @@
+#!/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

test/unit/chunks/wiki_test.rb

@@ -0,0 +1,98 @@
+#!/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

test/unit/file_yard_test.rb

@@ -0,0 +1,70 @@
+#!/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

test/unit/redcloth_for_tex_test.rb

@@ -0,0 +1,69 @@
+#!/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

test/unit/uri_test.rb

@@ -0,0 +1,217 @@
+#!/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

test/unit/wiki_words_test.rb

@@ -0,0 +1,14 @@
+#!/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