Module:Format link/testcases

 -- Unit tests for [[Module:Format link]]
 localmFormatLink=require('Module:Format link/sandbox')
 localscribuntoUnit=require('Module:ScribuntoUnit')
 localsuite=scribuntoUnit:new()

 --------------------------------------------------------------------------------
 -- Testing helper functions
 --------------------------------------------------------------------------------

 functionsuite:assertParentFrameCallEquals(expected,func,args)
 args=argsor{}
 localcurrent=mw.getCurrentFrame()
 localparent=current:newChild{title='Parent',args=args}
 localchild=parent:newChild{title='Child'}
 self:assertEquals(expected,func(child))
 end


 -------------------------------------------------------------------------------
 -- formatLink tests
 -------------------------------------------------------------------------------

 functionsuite:testFormatLink()
 self:assertEquals('[[:Foo]]',mFormatLink._formatLink{link='Foo'})
 end

 functionsuite:testFormatLinkColonHandling()
 self:assertEquals(
 '[[:Category:Foo]]',
 mFormatLink._formatLink{link=':Category:Foo'}
 )
 end

 functionsuite:testFormatLinkSectionLinking()
 self:assertEquals(
 '[[:Foo#Bar|Foo § Bar]]',
 mFormatLink._formatLink{link='Foo#Bar'}
 )
 end

 functionsuite:testFormatLinkPipeHandling()
 self:assertEquals(
 '[[:Foo|Bar]]',
 mFormatLink._formatLink{link='Foo|Bar'}
 )
 end

 functionsuite:testFormatLinkDisplay()
 self:assertEquals(
 '[[:Foo|Bar]]',
 mFormatLink._formatLink{link='Foo',display='Bar'}
 )
 end

 functionsuite:testFormatLinkDisplayOverwritesManualPiping()
 self:assertEquals(
 '[[:Foo|Baz]]',
 mFormatLink._formatLink{link='Foo|Bar',display='Baz'}
 )
 end

 functionsuite:testFormatLinkPageItalicization()
 self:assertEquals(
 "[[:Foo|<i>Foo</i>]]",
 mFormatLink._formatLink{link='Foo',italicizePage=true}
 )
 end

 functionsuite:testFormatLinkPageItalicizationWithSection()
 self:assertEquals(
 "[[:Foo#Bar|<i>Foo</i> §&nbsp;Bar]]",
 mFormatLink._formatLink{link='Foo#Bar',italicizePage=true}
 )
 end

 functionsuite:testFormatLinkSectionItalicization()
 self:assertEquals(
 "[[:Foo#Bar|Foo §&nbsp;<i>Bar</i>]]",
 mFormatLink._formatLink{link='Foo#Bar',italicizeSection=true}
 )
 end

 functionsuite:testFormatLinkPageItalicizationIsOverwrittenByDisplay()
 self:assertEquals(
 "[[:Foo#Bar|Baz]]",
 mFormatLink._formatLink{
 link='Foo#Bar',
 display='Baz',
 italicizePage=true,
 }
 )
 end

 functionsuite:testFormatLinkSectionItalicizationIsOverwrittenByDisplay()
 self:assertEquals(
 "[[:Foo#Bar|Baz]]",
 mFormatLink._formatLink{
 link='Foo#Bar',
 display='Baz',
 italicizeSection=true,
 }
 )
 end

 functionsuite:testFormatLinkItalicizationIsOverwrittenByManualPiping()
 self:assertEquals(
 "[[:Foo#Bar|Baz]]",
 mFormatLink._formatLink{
 link='Foo#Bar|Baz',
 italicizePage=true,
 italicizeSection=true,
 }
 )
 end

 functionsuite:testFormatLinkWithSectionOnlyLink()
 self:assertEquals(
 "[[:#Section|§&nbsp;Section]]",
 mFormatLink._formatLink{
 link='#Section',
 }
 )
 end

 functionsuite:testFormatLinkWithSectionOnlyLinkAndItalicizedSection()
 self:assertEquals(
 "[[:#Section|§&nbsp;<i>Section</i>]]",
 mFormatLink._formatLink{
 link='#Section',
 italicizeSection=true,
 }
 )
 end

 functionsuite:testFormatLinkWithSectionOnlyLinkAndItalicizedPage()
 self:assertEquals(
 "[[:#Section|§&nbsp;Section]]",
 mFormatLink._formatLink{
 link='#Section',
 italicizePage=true,
 }
 )
 end

 functionsuite:testFormatLinkEntryPoint()
 self:assertParentFrameCallEquals('[[:Foo]]',mFormatLink.formatLink,{'Foo'})
 self:assertParentFrameCallEquals(
 '[[:Foo|Bar]]',
 mFormatLink.formatLink,{'Foo','Bar'}
 )
 self:assertParentFrameCallEquals(
 "[[:Foo#Bar|<i>Foo</i> §&nbsp;<i>Bar</i>]]",
 mFormatLink.formatLink,
 {'Foo#Bar',italicizepage="yes",italicizesection="yes"}
 )
 self:assertParentFrameCallEquals(
 "[[:Foo#Bar|Foo §&nbsp;Bar]]",
 mFormatLink.formatLink,
 {'Foo#Bar',italicizepage="no",italicizesection="no"}
 )
 end

 functionsuite:testFormatLinkNonexistentPageCategorization()
 self:assertEquals(
 '[[:Nonexistent page]][[Category:Test]]',
 mFormatLink._formatLink{
 link='Nonexistent page',--*should* be nonexistent; is salted
 categorizeMissing='Test'
 }
 )
 end

 functionsuite:testFormatLinkTarget()
 self:assertEquals(
 '[[:Baz|Foo §&nbsp;Bar]]',
 mFormatLink._formatLink{
 link="Foo#Bar",
 target='Baz'
 }
 )
 end

 functionsuite:testFormatLinkTargetPiping()
 self:assertEquals(
 '[[:Baz|Boop]]',
 mFormatLink._formatLink{
 link="Foo#Bar|Boop",
 target='Baz'
 }
 )
 end

 -------------------------------------------------------------------------------
 -- formatPages tests
 -------------------------------------------------------------------------------

 functionsuite:testFormatPages()
 self:assertDeepEquals(
 {'[[:Foo]]','[[:Bar]]'},
 mFormatLink.formatPages({},{'Foo','Bar'})
 )
 end

 returnsuite