def setUp(self):
self.maxDiff = None
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
self.testPage = WikiPageFactory().create(self.wikiroot, "Страница", [])
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def testCommandTest7(self):
factory = ParserFactory()
parser = factory.make(self.testPage, self.application.config)
parser.addCommand(ExampleCommand(parser))
text = """(: test Параметр1 Параметр2=2 Параметр3=3 :)
Текст внутри
команды
(:testend:)
(: test Параметры :)
Контент
(:testend:)"""
result_right = """Command name: test
params: Параметр1 Параметр2=2 Параметр3=3
content: Текст внутри
команды
Command name: test
params: Параметры
content: Контент"""
result = parser.toHtml(text)
self.assertEqual(result_right, result, result)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def testCommandTest7 (self):
factory = ParserFactory ()
factory.appendCommand (TestCommand)
parser = factory.make (self.testPage, Application.config)
text = u"""(: test Параметр1 Параметр2=2 Параметр3=3 :)
Текст внутри
команды
(:testend:)
(: test Параметры :)
Контент
(:testend:)"""
result_right = u"""Command name: test
params: Параметр1 Параметр2=2 Параметр3=3
content: Текст внутри
команды
Command name: test
params: Параметры
content: Контент"""
result = parser.toHtml (text)
self.assertEqual (result_right, result, result)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
class WikiCounterCommandTest (unittest.TestCase):
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
dirlist = [u"../plugins/testcounter"]
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki (self.path)
def testPluginLoad (self):
self.assertEqual ( len (self.loader), 1)
def testCounter (self):
text = u"(:counter:) (:counter:)"
validResult = u"1 2"
result = self.parser.toHtml (text)
self.assertEqual (result, validResult)
# Проверим, что для нового парсера счетчик сбрасывается
parser2 = self.factory.make (self.testPage, Application.config)
result2 = parser2.toHtml (text)
self.assertEqual (result2, validResult)
def setUp(self):
self.initApplication()
self.filesPath = "../test/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, self.application.config)
def setUp(self):
self.encoding = "utf8"
self.__createWiki()
factory = ParserFactory()
self.testPage = self.rootwiki[u"Страница 2"]
self.parser = factory.make (self.testPage, Application.config)
def setUp(self):
self.initApplication()
self.filesPath = "testdata/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, self.application.config)
def setUp(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.filesPath = "../test/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.__createWiki()
dirlist = [u"../test/plugins/testwikicommand"]
loader = PluginsLoader(Application)
loader.load(dirlist)
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.filesPath = "testdata/samplefiles/"
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.__createWiki()
dirlist = [u"../plugins/testwikicommand"]
loader = PluginsLoader(Application)
loader.load (dirlist)
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
def testExceptionCommand (self):
factory = ParserFactory ()
factory.appendCommand (ExceptionCommand)
parser = factory.make (self.testPage, Application.config)
text = u"""(:exception:)"""
result = parser.toHtml(text)
# Исключение не должно бросаться, а должно быть выведено в результирующий текст
self.assertTrue ("Exception" in result, result)
def testExceptionCommand(self):
factory = ParserFactory()
parser = factory.make(self.testPage, Application.config)
parser.addCommand(ExceptionCommand(parser))
text = u"""(:exception:)"""
result = parser.toHtml(text)
# Исключение не должно бросаться, а должно быть выведено в результирующий текст
self.assertTrue("Exception" in result, result)
def setUp(self):
self.filesPath = "testdata/samplefiles/"
self.pagelinks = [
"Страница 1", "/Страница 1", "/Страница 2/Страница 3"
]
self.pageComments = ["Страницо 1", "Страницо 1", "Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.pagelinks = [u"Страница 1", u"/Страница 1", u"/Страница 2/Страница 3"]
self.pageComments = [u"Страницо 1", u"Страницо 1", u"Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.__createWiki()
self.testPage = self.wikiroot[u"Страница 1"]
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
filesPath = u"../test/samplefiles/"
self.files = [u"image.jpg", u"add.png", u"anchor.png", u"файл с пробелами.tmp", u"dir", u"for_sort"]
self.fullFilesPath = [os.path.join (filesPath, fname) for fname in self.files]
def setUp(self):
self.initApplication()
self.filesPath = "../test/samplefiles/"
self.__createWiki()
self._config = GeneralGuiConfig(self.application.config)
self._srcDateFormat = self._config.dateTimeFormat.value
self.testPage = self.wikiroot["Страница 1"]
self.testPage.creationdatetime = datetime(2014, 8, 20, 11, 59, 1)
self.testPage.datetime = datetime(2015, 9, 21, 12, 10, 20)
factory = ParserFactory()
self.parser = factory.make(self.testPage, self.application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.pagelinks = [u"Страница 1", u"/Страница 1", u"/Страница 2/Страница 3"]
self.pageComments = [u"Страницо 1", u"Страницо 1", u"Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.__wikiconfig = WikiConfig (Application.config)
self.__wikiconfig.thumbSizeOptions.value = WikiConfig.THUMB_SIZE_DEFAULT
self.parser = factory.make (self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.url1 = u"http://example.com"
self.url2 = u"http://jenyay.net/Photo/Nature?action=imgtpl&G=1&upname=tsaritsyno_01.jpg"
self.pagelinks = [u"Страница 1", u"/Страница 1", u"/Страница 2/Страница 3"]
self.pageComments = [u"Страницо 1", u"Страницо 1", u"Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
self._config = GeneralGuiConfig(Application.config)
self._srcDateFormat = self._config.dateTimeFormat.value
self.testPage = self.wikiroot[u"Страница 1"]
self.testPage.creationdatetime = datetime(2014, 8, 20, 11, 59, 1)
self.testPage.datetime = datetime(2015, 9, 21, 12, 10, 20)
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.pagelinks = [
u"Страница 1", u"/Страница 1", u"/Страница 2/Страница 3"
]
self.pageComments = [u"Страницо 1", u"Страницо 1", u"Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.__wikiconfig = WikiConfig(Application.config)
self.__wikiconfig.thumbSizeOptions.value = WikiConfig.THUMB_SIZE_DEFAULT
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.url1 = u"http://example.com"
self.url2 = u"http://jenyay.net/Photo/Nature?action=imgtpl&G=1&upname=tsaritsyno_01.jpg"
self.pagelinks = [
u"Страница 1", u"/Страница 1", u"/Страница 2/Страница 3"
]
self.pageComments = [u"Страницо 1", u"Страницо 1", u"Страницо 3"]
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
def setUp(self):
plugins_dir = [u"../plugins/snippets"]
self.loader = PluginsLoader(Application)
self.loader.load(plugins_dir)
self._createWiki()
self._application = Application
factory = ParserFactory()
self.parser = factory.make(self.testPage, self._application.config)
from snippets.utils import getSnippetsDir
root_snippets_dir = getSnippetsDir()
# snippets dir for tests
self._snippets_dir = os.path.join(
root_snippets_dir, u'__test_snippets')
os.mkdir(self._snippets_dir)
def setUp(self):
plugins_dir = [u"../plugins/snippets"]
self.loader = PluginsLoader(Application)
self.loader.load(plugins_dir)
self._createWiki()
self._application = Application
factory = ParserFactory()
self.parser = factory.make(self.testPage, self._application.config)
from snippets.utils import getSnippetsDir
root_snippets_dir = getSnippetsDir()
# snippets dir for tests
self._snippets_dir = os.path.join(root_snippets_dir,
u'__test_snippets')
os.mkdir(self._snippets_dir)
def setUp(self):
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot, "Страница 1",
[])
plugins_dir = ["../plugins/snippets"]
self.loader = PluginsLoader(self.application)
self.loader.load(plugins_dir)
factory = ParserFactory()
self.parser = factory.make(self.testPage, self.application.config)
from snippets.utils import getSnippetsDir
root_snippets_dir = getSnippetsDir()
# snippets dir for tests
self._snippets_dir = os.path.join(root_snippets_dir, '__test_snippets')
os.mkdir(self._snippets_dir)
def __createWiki (self):
# Здесь будет создаваться вики
self.filesPath = u"../test/samplefiles/"
self.wikiroot = WikiDocument.create (self.path)
WikiPageFactory().create (self.wikiroot, u"Страница 2", [])
self.testPage = self.wikiroot[u"Страница 2"]
files = [u"accept.png", u"add.png", u"anchor.png", u"filename.tmp",
u"файл с пробелами.tmp", u"картинка с пробелами.png",
u"image.jpg", u"image.jpeg", u"image.png", u"image.tif", u"image.tiff", u"image.gif",
u"image_01.JPG", u"dir", u"dir.xxx", u"dir.png"]
fullFilesPath = [os.path.join (self.filesPath, fname) for fname in files]
# Прикрепим к двум страницам файлы
Attachment (self.testPage).attach (fullFilesPath)
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
def setUp(self):
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot,
"Страница 1",
[])
plugins_dir = ["../plugins/snippets"]
self.loader = PluginsLoader(self.application)
self.loader.load(plugins_dir)
factory = ParserFactory()
self.parser = factory.make(self.testPage, self.application.config)
from snippets.utils import getSnippetsDir
root_snippets_dir = getSnippetsDir()
# snippets dir for tests
self._snippets_dir = os.path.join(
root_snippets_dir, '__test_snippets')
os.mkdir(self._snippets_dir)
def __createWiki(self):
# Здесь будет создаваться вики
self.filesPath = u"../test/samplefiles/"
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, u"Страница 2", [])
self.testPage = self.wikiroot[u"Страница 2"]
files = [
u"accept.png", u"add.png", u"anchor.png", u"filename.tmp",
u"файл с пробелами.tmp", u"картинка с пробелами.png", u"image.jpg",
u"image.jpeg", u"image.png", u"image.tif", u"image.tiff",
u"image.gif", u"image_01.JPG", u"dir", u"dir.xxx", u"dir.png"
]
fullFilesPath = [
os.path.join(self.filesPath, fname) for fname in files
]
# Прикрепим к двум страницам файлы
Attachment(self.testPage).attach(fullFilesPath)
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
class CommandExecTest (unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.__createWiki()
self.testPage = self.wikiroot[u'Страница 1']
dirlist = [u'../plugins/externaltools']
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
WikiPageFactory().create (self.wikiroot, u'Страница 1', [])
def tearDown(self):
removeDir (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual (len (self.loader), 1)
def testEmpty (self):
text = u'(:exec:)(:execend:)'
validResult = u''
result = self.parser.toHtml (text)
self.assertEqual (result, validResult)
def testLinkSimple_01 (self):
text = u'''(:exec:)gvim(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=gvim">gvim</a>
result = self.parser.toHtml (text)
self.assertIn (u'href="exec://exec/?', result)
self.assertIn (u'com1=gvim', result)
self.assertIn (u'title=gvim', result)
self.assertIn (u'>gvim</a>', result)
def testLinkSimple_02 (self):
text = u'''(:exec:)
gvim
(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=gvim">gvim</a>
result = self.parser.toHtml (text)
self.assertIn (u'href="exec://exec/?', result)
self.assertIn (u'com1=gvim', result)
self.assertIn (u'title=gvim', result)
self.assertIn (u'>gvim</a>', result)
def testLinkSimple_03 (self):
text = u'''(:exec:)
gvim -d "Первый файл.txt" "Второй файл.txt"
(:execend:)'''
# <a href="exec://exec/?com1=gvim&com1=-d&com1=%D0%9F%D0%B5%D1%80%D0%B2%D1%8B%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&com1=%D0%92%D1%82%D0%BE%D1%80%D0%BE%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&title=gvim">gvim</a>
result = self.parser.toHtml (text)
self.assertIn (u'href="exec://exec/?', result)
self.assertIn (u'com1=gvim&com1=-d&com1=%D0%9F%D0%B5%D1%80%D0%B2%D1%8B%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&com1=%D0%92%D1%82%D0%BE%D1%80%D0%BE%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt', result)
self.assertIn (u'title=gvim', result)
self.assertIn (u'>gvim</a>', result)
def testLinkTitle_01 (self):
text = u'''(:exec title="Запуск gvim":)gvim(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=%D0%97%D0%B0%D0%BF%D1%83%D1%81%D0%BA">Запуск gvim</a>
result = self.parser.toHtml (text)
self.assertIn (u'href="exec://exec/?', result)
self.assertIn (u'com1=gvim', result)
self.assertIn (u'title=%D0%97%D0%B0%D0%BF%D1%83%D1%81%D0%BA', result)
self.assertIn (u'>Запуск gvim</a>', result)
def testButton_01 (self):
text = u'''(:exec format="button":)gvim(:execend:)'''
# exec://exec/?com1=gvim&title=gvim
result = self.parser.toHtml (text)
self.assertIn (u'location.href="exec://exec/?', result)
self.assertIn (u'com1=gvim', result)
self.assertIn (u'title=gvim', result)
self.assertIn (u'<button', result)
self.assertIn (u'>gvim</button>', result)
def testButton_02 (self):
text = u'''(:exec format="button" title="Запуск":)gvim(:execend:)'''
result = self.parser.toHtml (text)
self.assertIn (u'location.href="exec://exec/?', result)
self.assertIn (u'com1=gvim', result)
self.assertIn (u'<button', result)
self.assertIn (u'>Запуск</button>', result)
class StylePluginTest (unittest.TestCase):
def setUp(self):
self.encoding = "866"
self.__createWiki()
dirlist = [u"../plugins/style"]
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual ( len (self.loader), 1)
def testStyleContentParse (self):
text = u"""Бла-бла-бла
(:style:)
body {font-size: 33px}
(:styleend:)
бла-бла-бла
"""
validResult = u"""Бла-бла-бла
бла-бла-бла
"""
styleresult = u"<STYLE>body {font-size: 33px}</STYLE>"
result = self.parser.toHtml (text)
self.assertEqual (result, validResult)
self.assertTrue (styleresult in self.parser.head)
def testFullHtml (self):
text = u"""Бла-бла-бла
(:style:)
body {font-size: 33px}
(:styleend:)
бла-бла-бла
"""
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
validStyle = u"<STYLE>body {font-size: 33px}</STYLE>"
self.assertTrue (validStyle in result, result)
def testFullHtml2 (self):
text = u"""Бла-бла-бла
(:style:)
body {font-size: 33px}
(:styleend:)
sdfsdf sdf
(:style:)
body {font-size: 10px}
(:styleend:)
бла-бла-бла
"""
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
validStyle1 = u"<STYLE>body {font-size: 33px}</STYLE>"
validStyle2 = u"<STYLE>body {font-size: 10px}</STYLE>"
self.assertTrue (validStyle1 in result, result)
self.assertTrue (validStyle2 in result, result)
def __readFile (self, path):
with open (path) as fp:
result = unicode (fp.read(), "utf8")
return result
class LightboxPluginTest(unittest.TestCase):
def setUp(self):
self.encoding = "utf8"
self.__createWiki()
dirlist = ["../plugins/lightbox"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, "Страница 1", [])
self.testPage = self.wikiroot["Страница 1"]
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testContentParse1(self):
text = """Бла-бла-бла (:lightbox:) бла-бла-бла"""
validResult = """$("a[href$='.jpg']"""
result = self.parser.toHtml(text)
self.assertTrue(validResult in result)
def testHeaders(self):
text = """Бла-бла-бла (:lightbox:) бла-бла-бла"""
self.parser.toHtml(text)
self.assertTrue(
'<script type="text/javascript" src="./__attach/__thumb/jquery-1.7.2.min.js"></script>'
in self.parser.head)
self.assertTrue(
'<link rel="stylesheet" href="./__attach/__thumb/jquery.fancybox.css" type="text/css" media="screen" />'
in self.parser.head)
self.assertTrue(
'<script type="text/javascript" src="./__attach/__thumb/jquery.fancybox.pack.js"></script>'
in self.parser.head)
def testSingleHeaders(self):
"""
Проверка, что заголовки добавляются только один раз
"""
text = """Бла-бла-бла (:lightbox:) бла-бла-бла (:lightbox:)"""
self.parser.toHtml(text)
header = '<script type="text/javascript" src="./__attach/__thumb/jquery-1.7.2.min.js"></script>'
posfirst = self.parser.head.find(header)
poslast = self.parser.head.rfind(header)
self.assertEqual(posfirst, poslast)
def testFiles(self):
text = """Бла-бла-бла (:lightbox:) бла-бла-бла"""
self.parser.toHtml(text)
dirname = "__attach/__thumb"
files = [
"jquery.fancybox.css", "blank.gif", "fancybox_loading.gif",
"jquery-1.7.2.min.js", "jquery.fancybox.pack.js",
"fancybox_sprite.png"
]
for fname in files:
fullpath = os.path.join(self.testPage.path, dirname, fname)
self.assertTrue(os.path.exists(fullpath))
class DiagrammerTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.filesPath = "../test/samplefiles/"
self.__createWiki()
dirlist = ["../plugins/diagrammer"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
self.thumbDir = os.path.join("__attach", "__thumb")
self.thumbFullPath = os.path.join(self.testPage.path, self.thumbDir)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, "Страница 1", [])
self.testPage = self.wikiroot["Страница 1"]
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testEmpty(self):
text = "(:diagram:)(:diagramend:)"
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn("<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def test_simple(self):
text = "(:diagram:)Абырвалг -> Блаблабла(:diagramend:)"
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn("<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def test_double(self):
text = """(:diagram:)Абырвалг -> Блаблабла(:diagramend:)
(:diagram:)Абыр -> валг -> Блаблабла(:diagramend:)"""
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn("<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 2)
def test_copy(self):
text = """(:diagram:)Абырвалг -> Блаблабла(:diagramend:)
(:diagram:)Абырвалг -> Блаблабла(:diagramend:)"""
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn("<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def testError(self):
text = "(:diagram:)a - b(:diagramend:)"
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertNotIn(validResult, result)
# Признак ошибки
self.assertIn("<b>", result)
# Папка для превьюшек все равно создается
self.assertTrue(os.path.exists(self.thumbFullPath))
def testShapes_01(self):
template = 'a{n}[shape = {shape}]'
shapes = [
"actor",
"beginpoint",
"box",
"circle",
"cloud",
"diamond",
"dots",
"ellipse",
"endpoint",
"mail",
"minidiamond",
"none",
"note",
"roundedbox",
"square",
"textbox",
"flowchart.database",
"flowchart.input",
"flowchart.loopin",
"flowchart.loopout",
"flowchart.terminator",
]
lines = ["(:diagram:)"]
for n, shape in zip(list(range(len(shapes))), shapes):
lines.append(template.format(n=n, shape=shape))
lines .append("(:diagramend:)")
text = "\n".join(lines)
validResult = '<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn("<b>", result)
def testShapes_02(self):
shapes = sorted([
"actor",
"beginpoint",
"box",
"circle",
"cloud",
"diamond",
"dots",
"ellipse",
"endpoint",
"mail",
"minidiamond",
"none",
"note",
"roundedbox",
"square",
"textbox",
"flowchart.database",
"flowchart.input",
"flowchart.loopin",
"flowchart.loopout",
"flowchart.terminator",
])
from diagrammer.diagramrender import DiagramRender
diagramShapers = DiagramRender.shapes
self.assertEqual(shapes, diagramShapers)
class CounterTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.filesPath = "testdata/samplefiles/"
self.__createWiki()
dirlist = ["plugins/counter"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, "Страница 1", [])
self.testPage = self.wikiroot["Страница 1"]
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testCounter_01(self):
text = "(:counter:)"
validResult = "1"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
# Проверим, что для нового парсера счетчик сбрасывается
parser2 = self.factory.make(self.testPage, Application.config)
result2 = parser2.toHtml(text)
self.assertEqual(result2, validResult)
def testCounter_02(self):
text = "(:counter:) (:counter:)"
validResult = "1 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
# Проверим, что для нового парсера счетчик сбрасывается
parser2 = self.factory.make(self.testPage, Application.config)
result2 = parser2.toHtml(text)
self.assertEqual(result2, validResult)
def testAlign_01(self):
text = "%center%(:counter:)"
validResult = '<div align="center">1</div>'
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testAlign_02(self):
text = "%center%Рисунок (:counter:)."
validResult = '<div align="center">Рисунок 1.</div>'
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testAlign_03(self):
text = "%center%Рисунок (:counter:).\nqqq"
validResult = '<div align="center">Рисунок 1.\nqqq</div>'
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testAlign_04(self):
text = "%center%Рисунок (:counter:).\n\nqqq"
validResult = '<div align="center">Рисунок 1.</div>\n\nqqq'
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testAlign_05(self):
text = "%center%Рисунок (:counter:). (:counter:).\n\nqqq"
validResult = '<div align="center">Рисунок 1. 2.</div>\n\nqqq'
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_01(self):
text = '(:counter name="Абырвалг":) (:counter name="Абырвалг":)'
validResult = "1 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_02(self):
text = '(:counter name="Абырвалг":) (:counter:)'
validResult = "1 1"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_03(self):
text = '(:counter name="Абырвалг":) (:counter:) (:counter name="Абырвалг":)'
validResult = "1 1 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_04(self):
text = '(:counter name="Абырвалг":) (:counter:) (:counter name="Абырвалг":) (:counter:)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_05(self):
text = '(:counter name="Абырвалг":) (:counter name:) (:counter name="Абырвалг":) (:counter name:)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_06(self):
text = '(:counter name="Абырвалг":) (:counter name="":) (:counter name="Абырвалг":) (:counter name="":)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_07(self):
text = '(:counter name="Абырвалг":) (:counter name="Новый счетчик":) (:counter name="Абырвалг":) (:counter name="Новый счетчик":)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_08(self):
text = '(:counter name=" Абырвалг":) (:counter name="Новый счетчик ":) (:counter name="Абырвалг":) (:counter name="Новый счетчик":)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testName_09(self):
text = '(:counter name=" Абырвалг":) (:counter name="Новый счетчик ":) (:counter name=" Абырвалг ":) (:counter name="Новый счетчик ":)'
validResult = "1 1 2 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_01(self):
text = "(:counter:) (:counter:) (:counter start=1:) (:counter:)"
validResult = "1 2 1 2"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_02(self):
text = "(:counter start=5:) (:counter:) (:counter:)"
validResult = "5 6 7"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_03(self):
text = "(:counter:) (:counter:) (:counter start=0:) (:counter:)"
validResult = "1 2 0 1"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_04(self):
text = '(:counter:) (:counter name="Абырвалг":) (:counter:) (:counter name="Абырвалг" start=10:) (:counter:)'
validResult = "1 1 2 10 3"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_05(self):
text = '(:counter start="-1":) (:counter:) (:counter:) (:counter start=10:)'
validResult = "-1 0 1 10"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_06(self):
text = '(:counter start="абырвалг":) (:counter:) (:counter:)'
validResult = "1 2 3"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStart_07(self):
text = '(:counter:) (:counter:) (:counter start="абырвалг":)'
validResult = "1 2 3"
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testParent_01(self):
text = '''(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 2" parent="level 1":)'''
validResult = '''1
1.1
1.2
1.3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testParent_02(self):
text = '''(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 3" parent="level 2":)'''
validResult = '''1
1.1
1.1.1
1.1.2'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testParent_03(self):
text = '''(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 2" parent="level 1":)'''
validResult = '''1
1.1
2
2.1
2.2'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testParent_04(self):
text = '''(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 3" parent="level 2":)
(:counter name="level 3" parent="level 2":)'''
validResult = '''1
1.1
1.1.1
1.1.2
1.2
1.2.1
1.2.2
2
2.1
2.1.1
2.1.2'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testInvalidParent_01(self):
text = '''(:counter name="level 1" parent="level 1":)'''
validResult = '''1'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testInvalidParent_02(self):
text = '''(:counter name="level 1":)
(:counter name="level 2" parent="level 1":)
(:counter name="level 1" parent="level 2":)
(:counter name="level 2" parent="level 1":)'''
validResult = '''1
1.1
1.1.1
1.1.1.1'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testInvalidParent_03(self):
text = '''(:counter name="level 1" parent="invalid":)
(:counter name="level 1" parent="invalid":)'''
validResult = '''1
2'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testFull_01(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)'''
validResult = '''Раздел 1
Раздел 2
Раздел 2.1
Раздел 2.1.1
Раздел 2.1.2
Раздел 2.1.3
Раздел 2.2
Раздел 2.3
Раздел 2.3.1
Раздел 2.3.2
Раздел 2.3.3
Раздел 2.3.3.1
Раздел 2.3.3.2
Раздел 2.3.3.3
Раздел 3
Раздел 3.1
Раздел 3.2
Раздел 3.3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testFull_02(self):
text = '''Раздел (:counter:)
Раздел (:counter:)
Раздел (:counter name="level 2" parent="":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 2" parent="":)
Раздел (:counter name="level 2" parent="":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 3" parent="level 2":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter name="level 4" parent="level 3":)
Раздел (:counter:)
Раздел (:counter name="level 2" parent="":)
Раздел (:counter name="level 2" parent="":)
Раздел (:counter name="level 2" parent="":)'''
validResult = '''Раздел 1
Раздел 2
Раздел 2.1
Раздел 2.1.1
Раздел 2.1.2
Раздел 2.1.3
Раздел 2.2
Раздел 2.3
Раздел 2.3.1
Раздел 2.3.2
Раздел 2.3.3
Раздел 2.3.3.1
Раздел 2.3.3.2
Раздел 2.3.3.3
Раздел 3
Раздел 3.1
Раздел 3.2
Раздел 3.3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testFull_03(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1" start=10:)
Раздел (:counter name="level 2" parent="level 1":)'''
validResult = '''Раздел 1
Раздел 1.1
Раздел 1.2
Раздел 1.10
Раздел 1.11'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testFull_04(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1" start=10:)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1":)'''
validResult = '''Раздел 1
Раздел 1.10
Раздел 1.11
Раздел 1.12
Раздел 1.13'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testHide_01(self):
text = '''(:counter hide:)'''
validResult = ''''''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testHide_02(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1" hide:)
Раздел (:counter name="level 2" parent="level 1":)
Раздел (:counter name="level 2" parent="level 1" start=10 hide:)
Раздел (:counter name="level 2" parent="level 1":)'''
validResult = '''Раздел 1
Раздел 1.1
Раздел
Раздел 1.3
Раздел
Раздел 1.11'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testHide_03(self):
text = '''(:counter start=100 hide:)(:counter:)'''
validResult = '''101'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_01(self):
text = '''(:counter:) (:counter step=2:)'''
validResult = '''1 3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_02(self):
text = '''(:counter step=2:)'''
validResult = '''2'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_03(self):
text = '''(:counter step=2:) (:counter step=3:) (:counter step=4:)'''
validResult = '''2 5 9'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_04(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1" step=2:)
Раздел (:counter name="level 2" parent="level 1" step=2:)'''
validResult = '''Раздел 1
Раздел 1.2
Раздел 1.4'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_05(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1" start=10 step="100":)
Раздел (:counter name="level 2" parent="level 1" step="100":)
Раздел (:counter name="level 2" parent="level 1" step="100":)
Раздел (:counter name="level 2" parent="level 1" step="100":)'''
validResult = '''Раздел 1
Раздел 1.10
Раздел 1.110
Раздел 1.210
Раздел 1.310'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_06(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1" start=0:)
Раздел (:counter name="level 2" parent="level 1" step=-100:)
Раздел (:counter name="level 2" parent="level 1" step=-100:)
Раздел (:counter name="level 2" parent="level 1" step=-100:)'''
validResult = '''Раздел 1
Раздел 1.0
Раздел 1.-100
Раздел 1.-200
Раздел 1.-300'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testStep_07(self):
text = '''(:counter start=0 step=2:)'''
validResult = '''0'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testSeparator_01(self):
text = '''Раздел (:counter name="level 1":)
Раздел (:counter name="level 2" parent="level 1" separator="/":)
Раздел (:counter name="level 2" parent="level 1" separator="/":)
Раздел (:counter name="level 2" parent="level 1" separator="/":)'''
validResult = '''Раздел 1
Раздел 1/1
Раздел 1/2
Раздел 1/3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testSeparator_02(self):
text = '''Раздел (:counter:)
Раздел (:counter name="level 2" parent="" separator=":":)
Раздел (:counter name="level 3" parent="level 2" separator="-":)
Раздел (:counter name="level 3" parent="level 2" separator="-":)
Раздел (:counter name="level 3" parent="level 2" separator="-":)
Раздел (:counter name="level 2" parent="" separator=":":)
Раздел (:counter name="level 2" parent="" separator="-":)'''
validResult = '''Раздел 1
Раздел 1:1
Раздел 1:1-1
Раздел 1:1-2
Раздел 1:1-3
Раздел 1:2
Раздел 1-3'''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
class ThumbListPluginTest (unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.encoding = "utf8"
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
dirlist = [u"../plugins/thumbgallery"]
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual ( len (self.loader), 1)
def testContentParseEmpty (self):
text = u"""Бла-бла-бла (:thumblist:) бла-бла-бла"""
validResult = u"""Бла-бла-бла <div class="thumblist"></div> бла-бла-бла"""
result = self.parser.toHtml (text)
self.assertEqual (validResult, result)
self.assertTrue (u"<table" not in result)
def testAttachFull1 (self):
text = u"""Бла-бла-бла
(:thumblist:)
бла-бла-бла"""
files = [u"first.jpg"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (os.path.exists (os.path.join (self.testPage.path, "__attach", "__thumb") ) )
self.assertTrue (u"<table" not in result)
def testAttachThumbListFull2 (self):
text = u"""Бла-бла-бла
(:thumblist:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGalleryFull2 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachEmpty1 (self):
text = u"""Бла-бла-бла
(:thumblist:)
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertFalse (u'<A HREF="__attach/first.jpg">' in result)
self.assertFalse (u"__thumb" in result)
self.assertFalse (u"_first.jpg" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGalleryEmpty1 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertFalse (u'<A HREF="__attach/first.jpg">' in result)
self.assertFalse (u"__thumb" in result)
self.assertFalse (u"_first.jpg" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachList1 (self):
text = u"""Бла-бла-бла
(:thumblist:)
first.jpg
particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachList2 (self):
text = u"""Бла-бла-бла
(:thumblist:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGalleryList2 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachList3 (self):
text = u"""Бла-бла-бла
(:thumblist:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGallery3 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGallerySpaces1 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt", u"картинка с пробелами.png"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"картинка с пробелами.png" in result)
self.assertTrue (u"_картинка с пробелами.png" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGallerySpaces2 (self):
text = u"""Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt", u"картинка с пробелами.png"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"картинка с пробелами.png" in result)
self.assertTrue (u"_картинка с пробелами.png" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGallerySize1 (self):
text = u"""Бла-бла-бла
(:thumbgallery maxsize=100:)
Attach:first.jpg
Attach:particle_01.PNG
Attach:картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt", u"картинка с пробелами.png"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"maxsize_100_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("maxsize_100_particle_01.PNG" in result)
self.assertTrue (u"картинка с пробелами.png" in result)
self.assertTrue (u"maxsize_100_картинка с пробелами.png" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"maxsize_100_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachGallerySize2 (self):
text = u"""Бла-бла-бла
(:thumbgallery px=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"maxsize_100_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("maxsize_100_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"maxsize_100_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachListSize1 (self):
text = u"""Бла-бла-бла
(:thumblist maxsize=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"maxsize_100_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("maxsize_100_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"maxsize_100_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachListSize2 (self):
text = u"""Бла-бла-бла
(:thumblist px=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"maxsize_100_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("maxsize_100_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"maxsize_100_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachListComments1 (self):
text = u"""Бла-бла-бла
(:thumblist px=100:)
Attach:first.jpg | Первый
Attach:particle_01.PNG|Комментарий к картинке
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"maxsize_100_first.jpg" in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue ("maxsize_100_particle_01.PNG" in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"maxsize_100_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testAttachListComments2 (self):
text = u"""Бла-бла-бла
(:thumblist:)
Attach:first.jpg | Первый
Attach:particle_01.PNG|Комментарий к картинке
(:thumblistend:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertFalse (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testTable1 (self):
text = u"""Бла-бла-бла
(:thumblist cols=2:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" in result)
# В таблице две строки
self.assertEqual (len (result.split ("<tr") ), 2 + 1)
def testTable2 (self):
text = u"""Бла-бла-бла
(:thumblist cols=1:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"particle_01.PNG", u"image.png", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u'<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" in result)
# В таблице две строки
self.assertEqual (len (result.split ("<tr") ), 4 + 1)
def testInvalidCols1 (self):
text = u"""Бла-бла-бла
(:thumblist cols:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testInvalidCols2 (self):
text = u"""Бла-бла-бла
(:thumblist cols=:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testInvalidCols3 (self):
text = u"""Бла-бла-бла
(:thumblist cols=abyrvalg:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
self.assertFalse (u"html.txt" in result)
self.assertTrue (u"<table" not in result)
def testInvalidThumbSizeStream (self):
text = u"""Абырвалг
(:thumblist px=abyrvalg:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u"бла-бла-бла" in result)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
def testInvalidThumbSizeTable (self):
text = u"""Абырвалг
(:thumblist px=abyrvalg сщды=3:)
бла-бла-бла"""
files = [u"first.jpg", u"image_01.JPG", u"html.txt"]
fullpath = [os.path.join (self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach (fullpath)
result = self.parser.toHtml (text)
self.assertTrue (u"бла-бла-бла" in result)
self.assertTrue (u'<A HREF="__attach/first.jpg">' in result)
self.assertTrue (u"__thumb" in result)
self.assertTrue (u"_first.jpg" in result)
self.assertTrue (u'<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue (u"_image_01.JPG" in result)
class HtmlHeadsTest (unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
self.testPage = self.wikiroot[u"Страница 1"]
dirlist = [u"../plugins/htmlheads"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
WikiPageFactory().create (self.wikiroot, u"Страница 1", [])
def tearDown(self):
removeDir (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual (len (self.loader), 1)
def testTitle_01 (self):
text = u'(:title Бла-бла-бла:)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u"<title>Бла-бла-бла</title>", result)
def testTitle_02 (self):
text = u'(:title Бла-бла-бла бла-бла :)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u"<title>Бла-бла-бла бла-бла</title>", result)
def testDescription_01 (self):
text = u'(:description Бла-бла-бла абырвалг:)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
def testDescription_02 (self):
text = u'(:description Бла-бла-бла абырвалг :)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
def testDescription_03 (self):
text = u'(:description:)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="description" content=""/>', result)
def testKeywords_01 (self):
text = u'(:keywords Бла-бла-бла, абырвалг:)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
def testKeywords_02 (self):
text = u'(:keywords Бла-бла-бла, абырвалг :)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
def testKeywords_03 (self):
text = u'(:keywords:)'
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="keywords" content=""/>', result)
def testHtmlHead_01 (self):
text = u'''(:htmlhead:)<meta name="keywords" content="Бла-бла-бла, абырвалг"/>(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
self.assertNotIn ("(:htmlhead:)", result)
def testHtmlHead_02 (self):
text = u'''(:htmlhead:)
<meta name="keywords" content="Бла-бла-бла, абырвалг"/>
<meta name="description" content="Бла-бла-бла абырвалг"/>
(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertIn (u'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
self.assertIn (u'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
self.assertNotIn ("(:htmlhead:)", result)
def testHtmlHead_03 (self):
text = u'''(:htmlhead:)(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
self.assertNotIn ("(:htmlhead:)", result)
class SpoilerPluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
def setUp(self):
self.__pluginname = "Spoiler"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot, "Страница 1",
[])
dirlist = ["plugins/spoiler"]
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testEmptyCommand(self):
text = '''bla-bla-bla (:spoiler:) bla-bla-bla'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("bla-bla-bla" in result)
def testSimple(self):
text = "бла-бла-бла (:spoiler:)Текст(:spoilerend:)"
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("Текст</div></div></div>" in result)
def testSimpleNumbers(self):
for index in range(10):
text = "бла-бла-бла (:spoiler{index}:)Текст(:spoiler{index}end:)".format(
index=index)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("Текст</div></div></div>" in result)
def testWikiBoldContent(self):
text = "бла-бла-бла (:spoiler:)'''Текст'''(:spoilerend:)"
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("<b>Текст</b></div></div></div>" in result)
def testExpandText(self):
text = """бла-бла-бла (:spoiler expandtext="Раскукожить":)Текст(:spoilerend:)"""
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("Текст</div></div></div>" in result)
self.assertTrue("Раскукожить</a></span></div>" in result)
def testCollapseText(self):
text = """бла-бла-бла (:spoiler collapsetext="Скукожить":)Текст(:spoilerend:)"""
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("Текст</div></div></div>" in result)
self.assertTrue("Скукожить</a>" in result)
def testExpandCollapseText(self):
text = """бла-бла-бла (:spoiler expandtext="Раскукожить" collapsetext="Скукожить":)Текст(:spoilerend:)"""
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertTrue("Текст</div></div></div>" in result)
self.assertTrue("Раскукожить</a></span></div>" in result)
self.assertTrue("Скукожить</a>" in result)
def testInline(self):
text = "бла-бла-бла (:spoiler inline:)Текст(:spoilerend:)"
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertFalse("Текст</div></div></div>" in result)
self.assertTrue("<span><span" in result)
def testInlineExpandText(self):
text = """бла-бла-бла (:spoiler expandtext="Раскукожить" inline:)Текст(:spoilerend:)"""
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("бла-бла-бла" in result)
self.assertFalse("Текст</div></div></div>" in result)
self.assertTrue("<span><span" in result)
self.assertTrue("""<a href="#">Раскукожить</a>""" in result)
class CommandExecParserTest (unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.__createWiki()
self.testPage = self.wikiroot['Страница 1']
self.testPageTextPath = os.path.join(self.testPage.path, '__page.text')
self.testPageHtmlPath = os.path.join(
self.testPage.path, PAGE_RESULT_HTML)
self.testPageAttachPath = Attachment(
self.testPage).getAttachPath(False)
dirlist = ['../plugins/externaltools']
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, 'Страница 1', [])
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testEmpty(self):
text = '(:exec:)(:execend:)'
validResult = ''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testCommandExecParser_01_empty(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 0)
def testCommandExecParser_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = 'gvim'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(len(result[0].params), 0)
def testCommandExecParser_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim
krusader'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(len(result[0].params), 0)
self.assertEqual(result[1].command, 'krusader')
self.assertEqual(len(result[1].params), 0)
def testCommandExecParser_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''
gvim
krusader
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(len(result[0].params), 0)
self.assertEqual(result[1].command, 'krusader')
self.assertEqual(len(result[1].params), 0)
def testCommandExecParser_05_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = 'gvim -d файл1.txt файл2.txt'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['-d', 'файл1.txt', 'файл2.txt'])
def testCommandExecParser_06_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ' gvim -d файл1.txt файл2.txt '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['-d', 'файл1.txt', 'файл2.txt'])
def testCommandExecParser_07_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ' gvim -d "Имя файла 1.txt" "Имя файла 2.txt" '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(
result[0].params, [
'-d', 'Имя файла 1.txt', 'Имя файла 2.txt'])
def testCommandExecParser_08_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = r' gvim -d "Имя файла 1\".txt" "Имя файла 2.txt" '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(
result[0].params, [
'-d', 'Имя файла 1".txt', 'Имя файла 2.txt'])
def testCommandExecParser_09_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''
gvim -d "Имя файла 1.txt" "Имя файла 2.txt"
krusader Параметр1 "Параметр 2 с пробелом"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(
result[0].params, [
'-d', 'Имя файла 1.txt', 'Имя файла 2.txt'])
self.assertEqual(result[1].command, 'krusader')
self.assertEqual(
result[1].params, [
'Параметр1', 'Параметр 2 с пробелом'])
def testCommandExecParser_10_join(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = r'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['Имя файла'])
def testCommandExecParser_11_join(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = r'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['Имя файла'])
def testCommandExecParser_join_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = r'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['Имя файла'])
def testCommandExecParser_13_invalid(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = r'''gvim \ asdfadsf'''
parser = CommandExecParser(self.testPage)
parser.parse(text)
def testCommandExecParser_14_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = 'gvim -d'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['-d'])
def testCommandExecParser_15_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = 'gvim "c:\\temp\\abyrvalg\\rrr\\nnn"'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['c:\\temp\\abyrvalg\\rrr\\nnn'])
def testMacrosPage_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %page%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPageTextPath])
def testMacrosPage_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %PAGE%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['%PAGE%'])
def testMacrosPage_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim \\
%page%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPageTextPath])
def testMacrosHtml_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %html%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPageHtmlPath])
def testMacrosFolder_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %folder%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPage.path])
def testMacrosFolder_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %folder%/111.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPage.path + '/111.txt'])
def testMacrosFolder_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %FOLDER%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['%FOLDER%'])
def testMacrosAttach_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %attach%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [self.testPageAttachPath])
def testMacrosAttach_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim %ATTACH%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['%ATTACH%'])
def testMacrosAttach_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim Attach:абырвалг.txt'''
attachPath = os.path.join(self.testPageAttachPath, 'абырвалг.txt')
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [attachPath])
def testMacrosAttach_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim "Attach:абырвалг главрыба.txt"'''
attachPath = os.path.join(
self.testPageAttachPath,
'абырвалг главрыба.txt')
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [attachPath])
def testMacrosAttach_05(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim xAttach:абырвалг.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['xAttach:абырвалг.txt'])
def testMacrosAttach_06(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim attach:абырвалг.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['attach:абырвалг.txt'])
def testMacrosApp_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''%folder%/gvim'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command,
self.testPage.path + '/gvim')
def testMacrosApp_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''%attach%/gvim'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command,
self.testPageAttachPath + '/gvim')
def testComments_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim fname
# Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim fname
# Комментарий
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''# Комментарий
gvim fname'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim fname # Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname', '#', 'Комментарий'])
def testComments_05(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim fname
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_06(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim fname \\
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_07(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim \\
#Комментарий
fname'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['fname'])
def testComments_08(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim \\
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['#Комментарий'])
def testComments_09(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim \\
#Комментарий
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, ['#Комментарий'])
def testComments_10(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = '''gvim
# Комментарий
krusader
# Комментарий 2
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, 'gvim')
self.assertEqual(result[0].params, [])
self.assertEqual(result[1].command, 'krusader')
self.assertEqual(result[1].params, [])
class HtmlHeadsTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.filesPath = "testdata/samplefiles/"
self.__createWiki()
self.testPage = self.wikiroot["Страница 1"]
dirlist = ["plugins/htmlheads"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, "Страница 1", [])
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testTitle_01(self):
text = '(:title Бла-бла-бла:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn("<title>Бла-бла-бла</title>", result)
def testTitle_02(self):
text = '(:title Бла-бла-бла бла-бла :)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn("<title>Бла-бла-бла бла-бла</title>", result)
def testDescription_01(self):
text = '(:description Бла-бла-бла абырвалг:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
def testDescription_02(self):
text = '(:description Бла-бла-бла абырвалг :)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
def testDescription_03(self):
text = '(:description:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn('<meta name="description" content=""/>', result)
def testKeywords_01(self):
text = '(:keywords Бла-бла-бла, абырвалг:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
def testKeywords_02(self):
text = '(:keywords Бла-бла-бла, абырвалг :)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
def testKeywords_03(self):
text = '(:keywords:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn('<meta name="keywords" content=""/>', result)
def testHtmlHead_01(self):
text = '''(:htmlhead:)<meta name="keywords" content="Бла-бла-бла, абырвалг"/>(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
self.assertNotIn("(:htmlhead:)", result)
def testHtmlHead_02(self):
text = '''(:htmlhead:)
<meta name="keywords" content="Бла-бла-бла, абырвалг"/>
<meta name="description" content="Бла-бла-бла абырвалг"/>
(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<meta name="keywords" content="Бла-бла-бла, абырвалг"/>', result)
self.assertIn(
'<meta name="description" content="Бла-бла-бла абырвалг"/>', result)
self.assertNotIn("(:htmlhead:)", result)
def testHtmlHead_03(self):
text = '''(:htmlhead:)(:htmlheadend:)'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertNotIn("(:htmlhead:)", result)
def testStyle_01(self):
text = '(:style:)body {color: blue};(:styleend:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn('''<style>body {color: blue};</style>''', result)
self.assertNotIn('(:style:)', result)
def testStyle_02(self):
text = '(:style:) body {color: blue}; (:styleend:)'
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn('''<style>body {color: blue};</style>''', result)
self.assertNotIn('(:style:)', result)
class ThumbListPluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
def setUp(self):
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot, "Страница 1",
[])
self.maxDiff = None
self.filesPath = "../test/samplefiles/"
dirlist = ["../plugins/thumbgallery"]
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testContentParseEmpty(self):
text = """Бла-бла-бла (:thumblist:) бла-бла-бла"""
validResult = """Бла-бла-бла <div class="thumblist"></div> бла-бла-бла"""
result = self.parser.toHtml(text)
self.assertEqual(validResult, result)
self.assertTrue("<table" not in result)
def testAttachFull1(self):
text = """Бла-бла-бла
(:thumblist:)
бла-бла-бла"""
files = ["first.jpg"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue(
os.path.exists(
os.path.join(self.testPage.path, "__attach", "__thumb")))
self.assertTrue("<table" not in result)
def testAttachThumbListFull2(self):
text = """Бла-бла-бла
(:thumblist:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGalleryFull2(self):
text = """Бла-бла-бла
(:thumbgallery:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachEmpty1(self):
text = """Бла-бла-бла
(:thumblist:)
(:thumblistend:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertFalse('<A HREF="__attach/first.jpg">' in result)
self.assertFalse("__thumb" in result)
self.assertFalse("_first.jpg" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGalleryEmpty1(self):
text = """Бла-бла-бла
(:thumbgallery:)
(:thumbgalleryend:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertFalse('<A HREF="__attach/first.jpg">' in result)
self.assertFalse("__thumb" in result)
self.assertFalse("_first.jpg" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachList1(self):
text = """Бла-бла-бла
(:thumblist:)
first.jpg
particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachList2(self):
text = """Бла-бла-бла
(:thumblist:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGalleryList2(self):
text = """Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachList3(self):
text = """Бла-бла-бла
(:thumblist:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGallery3(self):
text = """Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGallerySpaces1(self):
text = """Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
Attach:картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt", "картинка с пробелами.png"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue("картинка с пробелами.png" in result)
self.assertTrue("_картинка с пробелами.png" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGallerySpaces2(self):
text = """Бла-бла-бла
(:thumbgallery:)
Attach:first.jpg
картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt", "картинка с пробелами.png"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue("картинка с пробелами.png" in result)
self.assertTrue("_картинка с пробелами.png" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGallerySize1(self):
text = """Бла-бла-бла
(:thumbgallery maxsize=100:)
Attach:first.jpg
Attach:particle_01.PNG
Attach:картинка с пробелами.png
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt", "картинка с пробелами.png"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("maxsize_100_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("maxsize_100_particle_01.PNG" in result)
self.assertTrue("картинка с пробелами.png" in result)
self.assertTrue("maxsize_100_картинка с пробелами.png" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("maxsize_100_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachGallerySize2(self):
text = """Бла-бла-бла
(:thumbgallery px=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumbgalleryend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("maxsize_100_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("maxsize_100_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("maxsize_100_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachListSize1(self):
text = """Бла-бла-бла
(:thumblist maxsize=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("maxsize_100_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("maxsize_100_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("maxsize_100_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachListSize2(self):
text = """Бла-бла-бла
(:thumblist px=100:)
Attach:first.jpg
Attach:particle_01.PNG
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("maxsize_100_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("maxsize_100_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("maxsize_100_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachListComments1(self):
text = """Бла-бла-бла
(:thumblist px=100:)
Attach:first.jpg | Первый
Attach:particle_01.PNG|Комментарий к картинке
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("maxsize_100_first.jpg" in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue("maxsize_100_particle_01.PNG" in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("maxsize_100_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testAttachListComments2(self):
text = """Бла-бла-бла
(:thumblist:)
Attach:first.jpg | Первый
Attach:particle_01.PNG|Комментарий к картинке
(:thumblistend:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertFalse('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testTable1(self):
text = """Бла-бла-бла
(:thumblist cols=2:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" in result)
# В таблице две строки
self.assertEqual(len(result.split("<tr")), 2 + 1)
def testTable2(self):
text = """Бла-бла-бла
(:thumblist cols=1:)
бла-бла-бла"""
files = [
"first.jpg", "image_01.JPG", "particle_01.PNG", "image.png",
"html.txt"
]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue('<A HREF="__attach/particle_01.PNG">' in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" in result)
# В таблице две строки
self.assertEqual(len(result.split("<tr")), 4 + 1)
def testInvalidCols1(self):
text = """Бла-бла-бла
(:thumblist cols:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testInvalidCols2(self):
text = """Бла-бла-бла
(:thumblist cols=:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testInvalidCols3(self):
text = """Бла-бла-бла
(:thumblist cols=abyrvalg:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
self.assertFalse("html.txt" in result)
self.assertTrue("<table" not in result)
def testInvalidThumbSizeStream(self):
text = """Абырвалг
(:thumblist px=abyrvalg:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue("бла-бла-бла" in result)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
def testInvalidThumbSizeTable(self):
text = """Абырвалг
(:thumblist px=abyrvalg сщды=3:)
бла-бла-бла"""
files = ["first.jpg", "image_01.JPG", "html.txt"]
fullpath = [os.path.join(self.filesPath, fname) for fname in files]
Attachment(self.testPage).attach(fullpath)
result = self.parser.toHtml(text)
self.assertTrue("бла-бла-бла" in result)
self.assertTrue('<A HREF="__attach/first.jpg">' in result)
self.assertTrue("__thumb" in result)
self.assertTrue("_first.jpg" in result)
self.assertTrue('<A HREF="__attach/image_01.JPG">' in result)
self.assertTrue("_image_01.JPG" in result)
class SourcePluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
def setUp(self):
self.__pluginname = "Source"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot,
"Страница 1",
[])
dirlist = ["../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = "../test/samplefiles/sources"
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.config.tabWidth.value = 4
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
self.assertGreater(len(self.loader[self.__pluginname].url), 0)
def testEmptyCommand(self):
text = '''bla-bla-bla (:source:) bla-bla-bla'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("bla-bla-bla" in result)
def test1S(self):
text = '''(:source lang="1s":)
Функция УстановитьФизическиеЛица(Выборка)
Пока Выборка.Следующий() Цикл
//УстановитьФизическоеЛицо
ФизическоеЛицо = Справочники.ФизическиеЛица.НайтиПоНаименованию(Выборка.Ссылка);
Пользователь = Выборка.Ссылка.ПолучитьОбъект();
Пользователь.ФизическоеЛицо = ФизическоеЛицо;
Пользователь.Записать();
Сообщить("" + Пользователь + " " + Пользователь.ФизическоеЛицо + "-[ОК!]");
КонецЦикла;
КонецФункции
(:sourceend:)'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(
'<span class="c">//УстановитьФизическоеЛицо</span>', result)
self.assertIn('<span class="k">КонецФункции</span>', result)
def testFullHtmlPython(self):
text = '''(:source lang="python" tabwidth=5:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlPython2(self):
text = '''(:source lang="python":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlPython3(self):
# Неправильный размер табуляции
text = '''(:source lang="python" tabwidth="qqqqq":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlInvalidLang(self):
text = '''(:source lang="qqq" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' print "Hello world!!!"'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result, result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testFullHtmlText(self):
text = '''(:source lang="text" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' print "Hello world!!!"'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testFullHtmlText2(self):
text = '''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' print "Hello world!!!"'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testManySource(self):
text = '''(:source lang=python:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' print "Hello world!!!"'
innerString3 = 'def hello (count):'
innerString4 = ' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString5 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
# Проверка того, что стиль добавился только один раз
self.assertTrue(result.find(innerString1) ==
result.rfind(innerString1))
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
self.assertTrue(innerString5 in result)
self.assertFalse("(:source" in result)
def testConfigTabWidth(self):
text = '''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 10
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' for i in range (10)'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testConfigTabWidth2(self):
text = '''(:source tabwidth=10:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' for i in range (10)'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testConfigTabWidth3(self):
text = '''(:source tabwidth="-1":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' for i in range (10)'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testConfigTabWidth4(self):
text = '''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = -1
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = ' for i in range (10)'
innerString3 = 'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse("(:source" in result)
def testLineNum1(self):
text = '''(:source linenum:)
import os
import os.path
import sys
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = """ 1
2
3
4
5
6
7
8
9
10
11"""
self.assertTrue(innerString1 in result)
def setUp(self):
self.__createWiki()
self.testPage = self.wikiroot[u'Страница 1']
factory = ParserFactory()
self.parser = factory.make (self.testPage, Application.config)
def setUp(self):
self.__createWiki()
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
class DiagrammerTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.filesPath = u"../test/samplefiles/"
self.__createWiki()
dirlist = [u"../plugins/diagrammer"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
self.thumbDir = os.path.join(u"__attach", u"__thumb")
self.thumbFullPath = os.path.join(self.testPage.path, self.thumbDir)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, u"Страница 1", [])
self.testPage = self.wikiroot[u"Страница 1"]
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testEmpty(self):
text = u"(:diagram:)(:diagramend:)"
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn(u"<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def test_simple(self):
text = u"(:diagram:)Абырвалг -> Блаблабла(:diagramend:)"
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn(u"<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def test_double(self):
text = u"""(:diagram:)Абырвалг -> Блаблабла(:diagramend:)
(:diagram:)Абыр -> валг -> Блаблабла(:diagramend:)"""
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn(u"<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 2)
def test_copy(self):
text = u"""(:diagram:)Абырвалг -> Блаблабла(:diagramend:)
(:diagram:)Абырвалг -> Блаблабла(:diagramend:)"""
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn(u"<b>", result)
self.assertTrue(os.path.exists(self.thumbFullPath))
self.assertEqual(len(os.listdir(self.thumbFullPath)), 1)
def testError(self):
text = u"(:diagram:)a - b(:diagramend:)"
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertNotIn(validResult, result)
# Признак ошибки
self.assertIn(u"<b>", result)
# Папка для превьюшек все равно создается
self.assertTrue(os.path.exists(self.thumbFullPath))
def testShapes_01(self):
template = u'a{n}[shape = {shape}]'
shapes = [
"actor",
"beginpoint",
"box",
"circle",
"cloud",
"diamond",
"dots",
"ellipse",
"endpoint",
"mail",
"minidiamond",
"none",
"note",
"roundedbox",
"square",
"textbox",
"flowchart.database",
"flowchart.input",
"flowchart.loopin",
"flowchart.loopout",
"flowchart.terminator",
]
lines = [u"(:diagram:)"]
for n, shape in zip(range(len(shapes)), shapes):
lines.append(template.format(n=n, shape=shape))
lines.append(u"(:diagramend:)")
text = u"\n".join(lines)
validResult = u'<img src="{}/__diagram_'.format(self.thumbDir)
result = self.parser.toHtml(text)
self.assertIn(validResult, result)
# Признак ошибки
self.assertNotIn(u"<b>", result)
def testShapes_02(self):
shapes = sorted([
"actor",
"beginpoint",
"box",
"circle",
"cloud",
"diamond",
"dots",
"ellipse",
"endpoint",
"mail",
"minidiamond",
"none",
"note",
"roundedbox",
"square",
"textbox",
"flowchart.database",
"flowchart.input",
"flowchart.loopin",
"flowchart.loopout",
"flowchart.terminator",
])
from diagrammer.diagramrender import DiagramRender
diagramShapers = DiagramRender.shapes
self.assertEqual(shapes, diagramShapers)
class SourceEncodingPluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
"""
Тесты на работу с разными кодировками в плагине Source
"""
def setUp(self):
self.__pluginname = "Source"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot,
"Страница 1",
[])
dirlist = ["../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = "../test/samplefiles/sources"
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testHighlightFileEncoding1(self):
"""
Явное задание кодировки
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="cp1251":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' in result)
self.assertTrue('Ошибка соединения с сервером' in result)
def testHighlightFileEncoding2(self):
"""
Явное задание неправильной кодировки
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="utf8":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue('Ошибка соединения с сервером' not in result)
self.assertTrue('Source' in result)
def testHighlightFileEncoding3(self):
"""
Явное задание неправильной кодировки(которой нет в списке кодировок)
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue('Ошибка соединения с сервером' not in result)
self.assertTrue('Source' in result)
def testHighlightFileEncoding4(self):
"""
Явное задание неправильной кодировки(которой нет в списке кодировок)
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="kn">import</span> <span class="nn">os.path</span>' not in result)
self.assertTrue(
'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>' not in result)
self.assertTrue('Уничтожение(выгрузка) плагина.' not in result)
self.assertTrue('Source' in result)
def setUp(self):
self.__createWiki()
self.testPage = self.wikiroot[u'Страница 1']
factory = ParserFactory()
self.parser = factory.make(self.testPage, Application.config)
class SourcePluginTest(unittest.TestCase):
def setUp(self):
self.__pluginname = u"Source"
self.__createWiki()
dirlist = [u"../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = u"../test/samplefiles/sources"
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, u"Страница 1", [])
self.testPage = self.wikiroot[u"Страница 1"]
def tearDown(self):
self.config.tabWidth.value = 4
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
self.assertGreater(len(self.loader[self.__pluginname].url), 0)
def testEmptyCommand(self):
text = u'''bla-bla-bla (:source:) bla-bla-bla'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(u"bla-bla-bla" in result)
def test1S(self):
text = u'''(:source lang="1s":)
Функция УстановитьФизическиеЛица(Выборка)
Пока Выборка.Следующий() Цикл
//УстановитьФизическоеЛицо
ФизическоеЛицо = Справочники.ФизическиеЛица.НайтиПоНаименованию(Выборка.Ссылка);
Пользователь = Выборка.Ссылка.ПолучитьОбъект();
Пользователь.ФизическоеЛицо = ФизическоеЛицо;
Пользователь.Записать();
Сообщить("" + Пользователь + " " + Пользователь.ФизическоеЛицо + "-[ОК!]");
КонецЦикла;
КонецФункции
(:sourceend:)'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertIn(u'<span class="c">//УстановитьФизическоеЛицо</span>',
result)
self.assertIn(u'<span class="k">КонецФункции</span>', result)
def testFullHtmlPython(self):
text = u'''(:source lang="python" tabwidth=5:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlPython2(self):
text = u'''(:source lang="python":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlPython3(self):
# Неправильный размер табуляции
text = u'''(:source lang="python" tabwidth="qqqqq":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
def testFullHtmlInvalidLang(self):
text = u'''(:source lang="qqq" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result, result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testFullHtmlText(self):
text = u'''(:source lang="text" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testFullHtmlText2(self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testManySource(self):
text = u'''(:source lang=python:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
innerString4 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString5 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
# Проверка того, что стиль добавился только один раз
self.assertTrue(
result.find(innerString1) == result.rfind(innerString1))
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
self.assertTrue(innerString5 in result)
self.assertFalse(u"(:source" in result)
def testConfigTabWidth(self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 10
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testConfigTabWidth2(self):
text = u'''(:source tabwidth=10:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testConfigTabWidth3(self):
text = u'''(:source tabwidth="-1":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testConfigTabWidth4(self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = -1
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertFalse(u"(:source" in result)
def testLineNum1(self):
text = u'''(:source linenum:)
import os
import os.path
import sys
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = u""" 1
2
3
4
5
6
7
8
9
10
11"""
self.assertTrue(innerString1 in result)
class SourceStyleTest (unittest.TestCase):
def setUp(self):
self.__pluginname = u"Source"
self.__createWiki()
dirlist = [u"../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = u"../test/samplefiles/sources"
# Пример программы
self.pythonSource = u'''import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
'''
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
Application.config.remove_section (self.config.section)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
WikiPageFactory().create (self.wikiroot, u"Страница 1", [])
self.testPage = self.wikiroot[u"Страница 1"]
def tearDown(self):
self.config.tabWidth.value = 4
Application.config.remove_section (self.config.section)
removeDir (self.path)
self.loader.clear()
def testDefaultStyle (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testDefaultInvalidStyle (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "invalid_blablabla"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testDefaultEmptyStyle (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = ""
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testDefaultStyleVim (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim .c"
innerString2 = u".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testInvalidStyle (self):
text = u'(:source lang="python" tabwidth=4 style="invalid_bla-bla-bla":){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testStyleVim (self):
text = u'(:source lang="python" tabwidth=4 style="vim":){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim .c"
innerString2 = u".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
def testSeveralStyles (self):
text = u'''(:source lang="python" tabwidth=4 style="vim":){0}(:sourceend:)
(:source lang="python" tabwidth=4:){0}(:sourceend:)'''.format (self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim .c"
innerString2 = u".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = u' <span class="k">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = u'<span class="kn">import</span> <span class="nn">os</span>'
innerString5 = u".highlight-default .c"
innerString6 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
innerString7 = u'<div class="highlight-default">'
innerString8 = u'<div class="highlight-vim">'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
self.assertTrue (innerString5 in result)
self.assertTrue (innerString6 in result)
self.assertTrue (innerString7 in result)
self.assertTrue (innerString8 in result)
def testDefaultStyleFile (self):
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_utf8.py")])
text = u'(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
def testDefaultInvalidStyleFile (self):
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_utf8.py")])
text = u'(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "invalid_blablabla"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
def testDefaultEmptyStyleFile (self):
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_utf8.py")])
text = u'(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = ""
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-default .c"
innerString2 = u".highlight-default .c { color: #408080; font-style: italic } /* Comment */"
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
def testDefaultStyleVimFile (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim .c"
innerString2 = u".highlight-vim .c { color: #000080 } /* Comment */"
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
def testParentBg1 (self):
text = u'(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = u".highlight-vim {color: inherit; background-color: inherit }"
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 not in result)
def testParentBg2 (self):
text = u'(:source lang="python" tabwidth=4 parentbg:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = u".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = u'<div class="highlight-vim-parentbg">'
innerString4 = u".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = u'<div class="highlight-vim">'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 not in result)
self.assertTrue (innerString5 not in result)
def testParentBg3 (self):
text = u'(:source lang="python" parentbg tabwidth=4:){0}(:sourceend:)'.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = u".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = u'<div class="highlight-vim-parentbg">'
innerString4 = u".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = u'<div class="highlight-vim">'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 not in result)
self.assertTrue (innerString5 not in result)
def testParentBg4 (self):
text = u'''(:source lang="python" tabwidth=4:){0}(:sourceend:)
(:source lang="python" tabwidth=4 parentbg:){0}(:sourceend:)'''.format (self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator (self.testPage)
result = generator.makeHtml (Style().getPageStyle (self.testPage))
innerString1 = u".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = u".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = u'<div class="highlight-vim-parentbg">'
innerString4 = u".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = u'<div class="highlight-vim">'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 not in result)
self.assertTrue (innerString5 in result)
class SourcePluginTest (unittest.TestCase):
def setUp(self):
self.__pluginname = u"Source"
self.__createWiki()
dirlist = [u"../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = u"../test/samplefiles/sources"
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __readFile (self, path):
with open (path) as fp:
result = unicode (fp.read(), "utf8")
return result
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
self.config.tabWidth.value = 4
removeWiki (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual ( len (self.loader), 1)
self.assertGreater (len (self.loader[self.__pluginname].url), 0)
def testEmptyCommand (self):
text = u'''bla-bla-bla (:source:) bla-bla-bla'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
self.assertTrue (u"bla-bla-bla" in result)
def testFullHtmlPython (self):
text = u'''(:source lang="python" tabwidth=5:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
def testFullHtmlPython2 (self):
text = u'''(:source lang="python":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
def testFullHtmlPython3 (self):
# Неправильный размер табуляции
text = u'''(:source lang="python" tabwidth="qqqqq":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' <span class="k">print</span> <span class="s">"Hello world!!!"</span>'
innerString3 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
def testFullHtmlInvalidLang (self):
text = u'''(:source lang="qqq" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result, result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testFullHtmlText (self):
text = u'''(:source lang="text" tabwidth=4:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testFullHtmlText2 (self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testManySource (self):
text = u'''(:source lang=python:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' print "Hello world!!!"'
innerString3 = u'def hello (count):'
innerString4 = u' <span class="k">print</span> <span class="s">"Hello world!!!"</span>'
innerString5 = u'<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue (innerString1 in result)
# Проверка того, что стиль добавился только один раз
self.assertTrue (result.find (innerString1) == result.rfind (innerString1))
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertTrue (innerString4 in result)
self.assertTrue (innerString5 in result)
self.assertFalse (u"(:source" in result)
def testConfigTabWidth(self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 10
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testConfigTabWidth2(self):
text = u'''(:source tabwidth=10:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testConfigTabWidth3(self):
text = u'''(:source tabwidth="-1":)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testConfigTabWidth4(self):
text = u'''(:source:)
import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = -1
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u".highlight-default .go { color: #888888 } /* Generic.Output */"
innerString2 = u' for i in range (10)'
innerString3 = u'def hello (count):'
self.assertTrue (innerString1 in result)
self.assertTrue (innerString2 in result)
self.assertTrue (innerString3 in result)
self.assertFalse (u"(:source" in result)
def testLineNum1 (self):
text = u'''(:source linenum:)
import os
import os.path
import sys
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
(:sourceend:)
'''
self.config.tabWidth.value = 4
self.testPage.content = text
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
innerString1 = u""" 1
2
3
4
5
6
7
8
9
10
11"""
self.assertTrue (innerString1 in result)
class SourceEncodingPluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
"""
Тесты на работу с разными кодировками в плагине Source
"""
def setUp(self):
self.__pluginname = "Source"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot,
"Страница 1",
[])
dirlist = ["plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = "testdata/samplefiles/sources"
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testHighlightFileEncoding1(self):
"""
Явное задание кодировки
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="cp1251":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span><span class="w"> </span><span class="nn">System.Collections.Generic</span><span class="p">;</span><span class="w"></span' in result)
self.assertTrue('Ошибка соединения с сервером' in result)
def testHighlightFileEncoding2(self):
"""
Явное задание неправильной кодировки
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="utf8":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue('Ошибка соединения с сервером' not in result)
self.assertTrue('Source' in result)
def testHighlightFileEncoding3(self):
"""
Явное задание неправильной кодировки(которой нет в списке кодировок)
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_cp1251.cs")])
content = '(:source file="source_cp1251.cs" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue('Ошибка соединения с сервером' not in result)
self.assertTrue('Source' in result)
def testHighlightFileEncoding4(self):
"""
Явное задание неправильной кодировки(которой нет в списке кодировок)
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="kn">import</span> <span class="nn">os.path</span>' not in result)
self.assertTrue(
'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>' not in result)
self.assertTrue('Уничтожение(выгрузка) плагина.' not in result)
self.assertTrue('Source' in result)
class LightboxPluginTest (unittest.TestCase):
def setUp(self):
self.encoding = "utf8"
self.__createWiki()
dirlist = [u"../plugins/lightbox"]
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki (self.path)
self.loader.clear()
def testPluginLoad (self):
self.assertEqual ( len (self.loader), 1)
def testContentParse1 (self):
text = u"""Бла-бла-бла (:lightbox:) бла-бла-бла"""
validResult = u"""$("a[href$='.jpg']"""
result = self.parser.toHtml (text)
self.assertTrue (validResult in result)
def testHeaders (self):
text = u"""Бла-бла-бла (:lightbox:) бла-бла-бла"""
result = self.parser.toHtml (text)
self.assertTrue (u'<script type="text/javascript" src="./__attach/__thumb/jquery-1.7.2.min.js"></script>' in self.parser.head)
self.assertTrue (u'<link rel="stylesheet" href="./__attach/__thumb/jquery.fancybox.css" type="text/css" media="screen" />' in self.parser.head)
self.assertTrue (u'<script type="text/javascript" src="./__attach/__thumb/jquery.fancybox.pack.js"></script>' in self.parser.head)
def testSingleHeaders (self):
"""
Проверка, что заголовки добавляются только один раз
"""
text = u"""Бла-бла-бла (:lightbox:) бла-бла-бла (:lightbox:)"""
result = self.parser.toHtml (text)
header = u'<script type="text/javascript" src="./__attach/__thumb/jquery-1.7.2.min.js"></script>'
posfirst = self.parser.head.find (header)
poslast = self.parser.head.rfind (header)
self.assertEqual (posfirst, poslast)
def testFiles (self):
text = u"""Бла-бла-бла (:lightbox:) бла-бла-бла"""
result = self.parser.toHtml (text)
dirname = u"__attach/__thumb"
files = ["jquery.fancybox.css",
"blank.gif",
"fancybox_loading.gif",
"jquery-1.7.2.min.js",
"jquery.fancybox.pack.js",
"fancybox_sprite.png"
]
for fname in files:
fullpath = os.path.join (self.testPage.path, dirname, fname)
self.assertTrue (os.path.exists (fullpath))
class SourceFilePluginTest(unittest.TestCase):
"""
Тесты на работу с раскраской прикрепленных файлов
"""
def setUp(self):
self.__pluginname = u"Source"
self.__createWiki()
dirlist = [u"../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = u"../test/samplefiles/sources"
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __readFile(self, path):
with open(path) as fp:
result = unicode(fp.read(), "utf8")
return result
def __createWiki(self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki(self.path)
self.rootwiki = WikiDocument.create(self.path)
WikiPageFactory.create(self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki(self.path)
self.loader.clear()
def testHighlightFile1(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
def testHighlightFile2(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="Attach:source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
def testHighlightFile3(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file=" source_utf8.py " lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
def testHighlightFile4(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file=" Attach:source_utf8.py " lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
def testHighlightFile5(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" lang="text":)(:sourceend:)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
def testHighlightFile6(self):
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" lang="text":)bla-bla-bla(:sourceend:)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"__correctSysPath()" in result)
self.assertTrue(u"Плагин, добавляющий обработку команды (:source:) в википарсер" in result)
self.assertTrue(u"bla-bla-bla" not in result)
def testHighlightFile7(self):
"""
Явное задание языка для раскраски
"""
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" lang="python":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u'<span class="kn">import</span> <span class="nn">os.path</span>' in result)
self.assertTrue(
u'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
in result
)
def testHighlightFile8(self):
"""
Нет явного задания языка
"""
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u'<span class="kn">import</span> <span class="nn">os.path</span>' in result)
self.assertTrue(
u'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
in result
)
def testHighlightFile9(self):
"""
Явное задание языка, не соответствующее расширению файла
"""
Attachment(self.testPage).attach([os.path.join(self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u'<span class="kn">import</span> <span class="nn">os.path</span>' not in result)
self.assertTrue(u"import os.path" in result)
self.assertTrue(
u'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
not in result
)
self.assertTrue(u"__correctSysPath()" in result)
def testHighlightFile10(self):
"""
Проверка случая, если прикрепленного с заданным именем файла нет
"""
content = u'(:source file="source_utf8111.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
htmlpath = generator.makeHtml(Style().getPageStyle(self.testPage))
result = self.__readFile(htmlpath)
self.assertTrue(u"source_utf8111.py" in result, result)
class CommandExecTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.__createWiki()
self.testPage = self.wikiroot['Страница 1']
dirlist = ['../plugins/externaltools']
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, 'Страница 1', [])
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testEmpty(self):
text = '(:exec:)(:execend:)'
validResult = ''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testLinkSimple_01(self):
text = '''(:exec:)gvim(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=gvim">gvim</a>
result = self.parser.toHtml(text)
self.assertIn('href="exec://exec/?', result)
self.assertIn('com1=gvim', result)
self.assertIn('title=gvim', result)
self.assertIn('>gvim</a>', result)
def testLinkSimple_02(self):
text = '''(:exec:)
gvim
(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=gvim">gvim</a>
result = self.parser.toHtml(text)
self.assertIn('href="exec://exec/?', result)
self.assertIn('com1=gvim', result)
self.assertIn('title=gvim', result)
self.assertIn('>gvim</a>', result)
def testLinkSimple_03(self):
text = '''(:exec:)
gvim -d "Первый файл.txt" "Второй файл.txt"
(:execend:)'''
# <a href="exec://exec/?com1=gvim&com1=-d&com1=%D0%9F%D0%B5%D1%80%D0%B2%D1%8B%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&com1=%D0%92%D1%82%D0%BE%D1%80%D0%BE%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&title=gvim">gvim</a>
result = self.parser.toHtml(text)
self.assertIn('href="exec://exec/?', result)
self.assertIn(
'com1=gvim&com1=-d&com1=%D0%9F%D0%B5%D1%80%D0%B2%D1%8B%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt&com1=%D0%92%D1%82%D0%BE%D1%80%D0%BE%D0%B9+%D1%84%D0%B0%D0%B9%D0%BB.txt',
result)
self.assertIn('title=gvim', result)
self.assertIn('>gvim</a>', result)
def testLinkTitle_01(self):
text = '''(:exec title="Запуск gvim":)gvim(:execend:)'''
# <a href="exec://exec/?com1=gvim&title=%D0%97%D0%B0%D0%BF%D1%83%D1%81%D0%BA">Запуск gvim</a>
result = self.parser.toHtml(text)
self.assertIn('href="exec://exec/?', result)
self.assertIn('com1=gvim', result)
self.assertIn('title=%D0%97%D0%B0%D0%BF%D1%83%D1%81%D0%BA', result)
self.assertIn('>Запуск gvim</a>', result)
def testButton_01(self):
text = '''(:exec format="button":)gvim(:execend:)'''
# exec://exec/?com1=gvim&title=gvim
result = self.parser.toHtml(text)
self.assertIn('location.href="exec://exec/?', result)
self.assertIn('com1=gvim', result)
self.assertIn('title=gvim', result)
self.assertIn('<button', result)
self.assertIn('>gvim</button>', result)
def testButton_02(self):
text = '''(:exec format="button" title="Запуск":)gvim(:execend:)'''
result = self.parser.toHtml(text)
self.assertIn('location.href="exec://exec/?', result)
self.assertIn('com1=gvim', result)
self.assertIn('<button', result)
self.assertIn('>Запуск</button>', result)
class SourceStyleTest (unittest.TestCase, BaseOutWikerGUIMixin):
def setUp(self):
self.__pluginname = "Source"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot,
"Страница 1",
[])
dirlist = ["plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = "testdata/samplefiles/sources"
# Пример программы
self.pythonSource = '''import os
# Комментарий
def hello (count):
"""
Hello world
"""
for i in range (10):
print "Hello world!!!"
'''
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.application.config.remove_section(self.config.section)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.config.tabWidth.value = 4
self.application.config.remove_section(self.config.section)
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testDefaultStyle(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testDefaultInvalidStyle(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "invalid_blablabla"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testDefaultEmptyStyle(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = ""
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testDefaultStyleVim(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim .c"
innerString2 = ".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testInvalidStyle(self):
text = '(:source lang="python" tabwidth=4 style="invalid_bla-bla-bla":){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testStyleVim(self):
text = '(:source lang="python" tabwidth=4 style="vim":){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim .c"
innerString2 = ".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
def testSeveralStyles(self):
text = '''(:source lang="python" tabwidth=4 style="vim":){0}(:sourceend:)
(:source lang="python" tabwidth=4:){0}(:sourceend:)'''.format(self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim .c"
innerString2 = ".highlight-vim .c { color: #000080 } /* Comment */"
innerString3 = ' <span class="nb">print</span> <span class="s2">"Hello world!!!"</span>'
innerString4 = '<span class="kn">import</span> <span class="nn">os</span>'
innerString5 = ".highlight-default .c"
innerString6 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
innerString7 = '<div class="highlight-default">'
innerString8 = '<div class="highlight-vim">'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 in result)
self.assertTrue(innerString5 in result)
self.assertTrue(innerString6 in result)
self.assertTrue(innerString7 in result)
self.assertTrue(innerString8 in result)
def testDefaultStyleFile(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
text = '(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
def testDefaultInvalidStyleFile(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
text = '(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "invalid_blablabla"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
def testDefaultEmptyStyleFile(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
text = '(:source lang="python" tabwidth=4 file="source_utf8.py":){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = ""
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-default .c"
innerString2 = ".highlight-default .c { color: #3D7B7B; font-style: italic } /* Comment */"
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
def testDefaultStyleVimFile(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim .c"
innerString2 = ".highlight-vim .c { color: #000080 } /* Comment */"
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
def testParentBg1(self):
text = '(:source lang="python" tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = ".highlight-vim {color: inherit; background-color: inherit }"
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 not in result)
def testParentBg2(self):
text = '(:source lang="python" tabwidth=4 parentbg:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = ".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = '<div class="highlight-vim-parentbg">'
innerString4 = ".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = '<div class="highlight-vim">'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 not in result)
self.assertTrue(innerString5 not in result)
def testParentBg3(self):
text = '(:source lang="python" parentbg tabwidth=4:){0}(:sourceend:)'.format(
self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = ".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = '<div class="highlight-vim-parentbg">'
innerString4 = ".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = '<div class="highlight-vim">'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 not in result)
self.assertTrue(innerString5 not in result)
def testParentBg4(self):
text = '''(:source lang="python" tabwidth=4:){0}(:sourceend:)
(:source lang="python" tabwidth=4 parentbg:){0}(:sourceend:)'''.format(self.pythonSource)
self.testPage.content = text
self.config.defaultStyle.value = "vim"
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
innerString1 = ".highlight-vim-parentbg pre {padding: 0px; border: none; color: inherit; background-color: inherit; margin:0px; }"
innerString2 = ".highlight-vim-parentbg {color: inherit; background-color: inherit }"
innerString3 = '<div class="highlight-vim-parentbg">'
innerString4 = ".highlight-vim {color: inherit; background-color: inherit }"
innerString5 = '<div class="highlight-vim">'
self.assertTrue(innerString1 in result)
self.assertTrue(innerString2 in result)
self.assertTrue(innerString3 in result)
self.assertTrue(innerString4 not in result)
self.assertTrue(innerString5 in result)
class CommandExecParserTest(unittest.TestCase):
def setUp(self):
self.maxDiff = None
self.__createWiki()
self.testPage = self.wikiroot[u'Страница 1']
self.testPageTextPath = os.path.join(self.testPage.path,
u'__page.text')
self.testPageHtmlPath = os.path.join(self.testPage.path,
PAGE_RESULT_HTML)
self.testPageAttachPath = Attachment(
self.testPage).getAttachPath(False)
dirlist = [u'../plugins/externaltools']
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, Application.config)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, u'Страница 1', [])
def tearDown(self):
removeDir(self.path)
self.loader.clear()
def testPluginLoad(self):
self.assertEqual(len(self.loader), 1)
def testEmpty(self):
text = u'(:exec:)(:execend:)'
validResult = u''
result = self.parser.toHtml(text)
self.assertEqual(result, validResult)
def testCommandExecParser_01_empty(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 0)
def testCommandExecParser_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'gvim'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(len(result[0].params), 0)
def testCommandExecParser_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim
krusader'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(len(result[0].params), 0)
self.assertEqual(result[1].command, u'krusader')
self.assertEqual(len(result[1].params), 0)
def testCommandExecParser_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''
gvim
krusader
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(len(result[0].params), 0)
self.assertEqual(result[1].command, u'krusader')
self.assertEqual(len(result[1].params), 0)
def testCommandExecParser_05_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'gvim -d файл1.txt файл2.txt'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'-d', u'файл1.txt', u'файл2.txt'])
def testCommandExecParser_06_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u' gvim -d файл1.txt файл2.txt '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'-d', u'файл1.txt', u'файл2.txt'])
def testCommandExecParser_07_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u' gvim -d "Имя файла 1.txt" "Имя файла 2.txt" '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params,
[u'-d', u'Имя файла 1.txt', u'Имя файла 2.txt'])
def testCommandExecParser_08_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ur' gvim -d "Имя файла 1\".txt" "Имя файла 2.txt" '
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params,
[u'-d', u'Имя файла 1".txt', u'Имя файла 2.txt'])
def testCommandExecParser_09_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''
gvim -d "Имя файла 1.txt" "Имя файла 2.txt"
krusader Параметр1 "Параметр 2 с пробелом"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params,
[u'-d', u'Имя файла 1.txt', u'Имя файла 2.txt'])
self.assertEqual(result[1].command, u'krusader')
self.assertEqual(result[1].params,
[u'Параметр1', u'Параметр 2 с пробелом'])
def testCommandExecParser_10_join(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ur'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'Имя файла'])
def testCommandExecParser_11_join(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ur'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'Имя файла'])
def testCommandExecParser_join_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ur'''gvim \
"Имя файла"
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'Имя файла'])
def testCommandExecParser_13_invalid(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = ur'''gvim \ asdfadsf'''
parser = CommandExecParser(self.testPage)
parser.parse(text)
def testCommandExecParser_14_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'gvim -d'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'-d'])
def testCommandExecParser_15_params(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'gvim "c:\\temp\\abyrvalg\\rrr\\nnn"'
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'c:\\temp\\abyrvalg\\rrr\\nnn'])
def testMacrosPage_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %page%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPageTextPath])
def testMacrosPage_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %PAGE%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'%PAGE%'])
def testMacrosPage_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim \\
%page%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPageTextPath])
def testMacrosHtml_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %html%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPageHtmlPath])
def testMacrosFolder_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %folder%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPage.path])
def testMacrosFolder_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %folder%/111.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPage.path + u'/111.txt'])
def testMacrosFolder_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %FOLDER%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'%FOLDER%'])
def testMacrosAttach_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %attach%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [self.testPageAttachPath])
def testMacrosAttach_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim %ATTACH%'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'%ATTACH%'])
def testMacrosAttach_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim Attach:абырвалг.txt'''
attachPath = os.path.join(self.testPageAttachPath, u'абырвалг.txt')
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [attachPath])
def testMacrosAttach_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim "Attach:абырвалг главрыба.txt"'''
attachPath = os.path.join(self.testPageAttachPath,
u'абырвалг главрыба.txt')
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [attachPath])
def testMacrosAttach_05(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim xAttach:абырвалг.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'xAttach:абырвалг.txt'])
def testMacrosAttach_06(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim attach:абырвалг.txt'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'attach:абырвалг.txt'])
def testMacrosApp_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''%folder%/gvim'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, self.testPage.path + u'/gvim')
def testMacrosApp_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''%attach%/gvim'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, self.testPageAttachPath + u'/gvim')
def testComments_01(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim fname
# Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_02(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim fname
# Комментарий
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_03(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''# Комментарий
gvim fname'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_04(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim fname # Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname', u'#', u'Комментарий'])
def testComments_05(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim fname
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_06(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim fname \\
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_07(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim \\
#Комментарий
fname'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'fname'])
def testComments_08(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim \\
#Комментарий'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'#Комментарий'])
def testComments_09(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim \\
#Комментарий
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [u'#Комментарий'])
def testComments_10(self):
from externaltools.commandexec.commandexecparser import CommandExecParser
text = u'''gvim
# Комментарий
krusader
# Комментарий 2
'''
parser = CommandExecParser(self.testPage)
result = parser.parse(text)
self.assertEqual(len(result), 2)
self.assertEqual(result[0].command, u'gvim')
self.assertEqual(result[0].params, [])
self.assertEqual(result[1].command, u'krusader')
self.assertEqual(result[1].params, [])
class SourceFilePluginTest(unittest.TestCase, BaseOutWikerGUIMixin):
"""
Тесты на работу с раскраской прикрепленных файлов
"""
def setUp(self):
self.__pluginname = "Source"
self.initApplication()
self.wikiroot = self.createWiki()
self.testPage = WikiPageFactory().create(self.wikiroot, "Страница 1",
[])
dirlist = ["plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = "testdata/samplefiles/sources"
self.loader = PluginsLoader(self.application)
self.loader.load(dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make(self.testPage, self.application.config)
def tearDown(self):
self.loader.clear()
self.destroyApplication()
self.destroyWiki(self.wikiroot)
def testHighlightFile1(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
def testHighlightFile2(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="Attach:source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
def testHighlightFile3(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file=" source_utf8.py " lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
def testHighlightFile4(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file=" Attach:source_utf8.py " lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
def testHighlightFile5(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" lang="text":)(:sourceend:)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
def testHighlightFile6(self):
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" lang="text":)bla-bla-bla(:sourceend:)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue("__correctSysPath()" in result)
self.assertTrue(
"Плагин, добавляющий обработку команды (:source:) в википарсер" in
result)
self.assertTrue("bla-bla-bla" not in result)
def testHighlightFile7(self):
"""
Явное задание языка для раскраски
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" lang="python":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="kn">import</span> <span class="nn">os.path</span>' in
result)
self.assertTrue(
'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
in result)
def testHighlightFile8(self):
"""
Нет явного задания языка
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="kn">import</span> <span class="nn">os.path</span>' in
result)
self.assertTrue(
'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
in result)
def testHighlightFile9(self):
"""
Явное задание языка, не соответствующее расширению файла
"""
Attachment(self.testPage).attach(
[os.path.join(self.samplefilesPath, "source_utf8.py")])
content = '(:source file="source_utf8.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue(
'<span class="kn">import</span> <span class="nn">os.path</span>'
not in result)
self.assertTrue('import os.path' in result)
self.assertTrue(
'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>'
not in result)
self.assertTrue("__correctSysPath()" in result)
def testHighlightFile10(self):
"""
Проверка случая, если прикрепленного с заданным именем файла нет
"""
content = '(:source file="source_utf8111.py" lang="text":)'
self.testPage.content = content
generator = HtmlGenerator(self.testPage)
result = generator.makeHtml(Style().getPageStyle(self.testPage))
self.assertTrue('source_utf8111.py' in result, result)
class SourceEncodingPluginTest (unittest.TestCase):
"""
Тесты на работу с разными кодировками в плагине Source
"""
def setUp(self):
self.__pluginname = u"Source"
self.__createWiki()
dirlist = [u"../plugins/source"]
# Путь, где лежат примеры исходников в разных кодировках
self.samplefilesPath = u"../test/samplefiles/sources"
self.loader = PluginsLoader(Application)
self.loader.load (dirlist)
self.config = self.loader[self.__pluginname].config
self.config.tabWidth.value = 4
self.config.defaultLanguage.remove_option()
self.factory = ParserFactory()
self.parser = self.factory.make (self.testPage, Application.config)
def __readFile (self, path):
with open (path) as fp:
result = unicode (fp.read(), "utf8")
return result
def __createWiki (self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
self.testPage = self.rootwiki[u"Страница 1"]
def tearDown(self):
removeWiki (self.path)
self.loader.clear()
def testHighlightFileEncoding1 (self):
"""
Явное задание кодировки
"""
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_cp1251.cs")])
content = u'(:source file="source_cp1251.cs" encoding="cp1251":)'
self.testPage.content = content
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
self.assertTrue (u'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' in result)
self.assertTrue (u'Ошибка соединения с сервером' in result)
def testHighlightFileEncoding2 (self):
"""
Явное задание неправильной кодировки
"""
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_cp1251.cs")])
content = u'(:source file="source_cp1251.cs" encoding="utf8":)'
self.testPage.content = content
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
self.assertTrue (u'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue (u'Ошибка соединения с сервером' not in result)
self.assertTrue (u'Source' in result)
def testHighlightFileEncoding3 (self):
"""
Явное задание неправильной кодировки (которой нет в списке кодировок)
"""
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_cp1251.cs")])
content = u'(:source file="source_cp1251.cs" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
self.assertTrue (u'<span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>' not in result)
self.assertTrue (u'Ошибка соединения с сервером' not in result)
self.assertTrue (u'Source' in result)
def testHighlightFileEncoding4 (self):
"""
Явное задание неправильной кодировки (которой нет в списке кодировок)
"""
Attachment(self.testPage).attach ([os.path.join (self.samplefilesPath, u"source_utf8.py")])
content = u'(:source file="source_utf8.py" encoding="blablabla":)'
self.testPage.content = content
generator = HtmlGenerator (self.testPage)
htmlpath = generator.makeHtml (Style().getPageStyle (self.testPage))
result = self.__readFile (htmlpath)
self.assertTrue (u'<span class="kn">import</span> <span class="nn">os.path</span>' not in result)
self.assertTrue (u'<span class="bp">self</span><span class="o">.</span><span class="n">__correctSysPath</span><span class="p">()</span>' not in result)
self.assertTrue (u'Уничтожение (выгрузка) плагина.' not in result)
self.assertTrue (u'Source' in result)
