def testInvalidWikiRoot2 (self):
"""
Тест на обработку ошибки в файле __page.opt корня вики
"""
def __createInvalidWiki2 ():
# Здесь будет создаваться вики
path = mkdtemp (prefix=u'Абырвалг абыр')
removeDir (path)
rootwiki = WikiDocument.create (path)
factory = TextPageFactory()
factory.create (rootwiki, u"Страница 1", [])
factory.create (rootwiki[u"Страница 1"], u"Страница 2", [])
# Испортим файл __page.opt
with open (os.path.join (rootwiki.path, u"__page.opt"), "w") as fp:
fp.write (u"[General]\naaa=xxx\n<<<<<<<<wsfsdf sdf sdfasdfdsf \nasfasdsadf")
return path
path = __createInvalidWiki2 ()
WikiDocument.load (path)
removeDir (path)
def testSubwikiParams (self):
"""
Проверка того, что установка параметров страницы как полноценной вики не портит исходные параметры
"""
param = StringOption (self.wikiroot["Страница 1"].params, "TestSection_1", "value1", "")
param.value = "Значение 1"
path = os.path.join (self.path, "Страница 1")
subwiki = WikiDocument.load (path)
subwikiparam = StringOption (subwiki.params, "TestSection_1", "value1", "")
self.assertEqual (subwikiparam.value, "Значение 1")
# Добавим новый параметр
subwikiparam1 = StringOption (subwiki.params, "TestSection_1", "value1", "")
subwikiparam2 = StringOption (subwiki.params, "TestSection_2", "value2", "")
subwikiparam2.value = "Значение 2"
self.assertEqual (subwikiparam1.value, "Значение 1")
self.assertEqual (subwikiparam2.value, "Значение 2")
# На всякий случай прочитаем вики еще раз
wiki = WikiDocument.load (self.path)
wikiparam1 = StringOption (wiki["Страница 1"].params, "TestSection_1", "value1", "")
wikiparam2 = StringOption (wiki["Страница 1"].params, "TestSection_2", "value2", "")
self.assertEqual (wikiparam1.value, "Значение 1")
self.assertEqual (wikiparam2.value, "Значение 2")
def testPageSelectLoad (self):
Application.onPageSelect += self.pageSelect
removeWiki (self.path)
rootwiki = WikiDocument.create (self.path)
TextPageFactory.create (rootwiki, u"Страница 1", [])
TextPageFactory.create (rootwiki, u"Страница 2", [])
TextPageFactory.create (rootwiki[u"Страница 2"], u"Страница 3", [])
document = WikiDocument.load (self.path)
Application.wikiroot = document
self.assertEqual (document.selectedPage, None)
document.selectedPage = document[u"Страница 1"]
self.assertEqual (document.selectedPage, document[u"Страница 1"])
self.assertEqual (self.isPageSelect, True)
self.assertEqual (self.pageSelectSender, document[u"Страница 1"])
self.assertEqual (self.pageSelectCount, 1)
document.selectedPage = document[u"Страница 2/Страница 3"]
self.assertEqual (document.selectedPage, document[u"Страница 2/Страница 3"])
self.assertEqual (self.isPageSelect, True)
self.assertEqual (self.pageSelectSender, document[u"Страница 2/Страница 3"])
self.assertEqual (self.pageSelectCount, 2)
Application.onPageSelect -= self.pageSelect
def testChangeContent(self):
from webpage.webnotepage import WebPageFactory
wikiroot = WikiDocument.create(self.path)
test_page = WebPageFactory().create(wikiroot, "Страница 1", [])
test_page.content = "Абырвалг"
self.application.wikiroot = wikiroot
self.application.selectedPage = test_page
pageview = self.application.mainWindow.pagePanel.pageView
pageview.codeEditor.SetText("Бла-бла-бла")
pageview.Save()
self.application.selectedPage = None
self.application.wikiroot = None
wikiroot_other = WikiDocument.load(self.path)
self.application.wikiroot = wikiroot_other
self.application.selectedPage = wikiroot_other["Страница 1"]
pageview = self.application.mainWindow.pagePanel.pageView
pageContent = pageview.codeEditor.GetText()
self.assertEqual(pageContent, "Бла-бла-бла")
def __rootFormatErrorHandle(path, readonly):
"""
Обработчик исключения outwiker.core.exceptions.RootFormatError
"""
if readonly:
# Если вики открыт только для чтения, то нельзя изменять файлы
__canNotLoadWikiMessage(path)
return
if (__wantClearWikiOptions(path) != wx.YES):
return
# Обнулим файл __page.opt
WikiDocument.clearConfigFile(path)
# Попробуем открыть вики еще раз
try:
# Загрузить вики
wikiroot = WikiDocument.load(os.path.realpath(path), readonly)
Application.wikiroot = wikiroot
except IOError:
__canNotLoadWikiMessage(path)
except outwiker.core.exceptions.RootFormatError:
__canNotLoadWikiMessage(path)
finally:
pass
def testInvalidWikiRoot2 (self):
"""
Тест на обработку ошибки в файле __page.opt корня вики
"""
def __createInvalidWiki2 ():
# Здесь будет создаваться вики
path = u"../test/testwiki"
removeWiki (path)
rootwiki = WikiDocument.create (path)
TextPageFactory.create (rootwiki, u"Страница 1", [])
TextPageFactory.create (rootwiki[u"Страница 1"], u"Страница 2", [])
# Испортим файл __page.opt
with open (os.path.join (rootwiki.path, u"__page.opt"), "w") as fp:
fp.write (u"[General]\naaa=xxx\n<<<<<<<<wsfsdf sdf sdfasdfdsf \nasfasdsadf")
return path
path = __createInvalidWiki2 ()
self.assertRaises (RootFormatError, WikiDocument.load, path)
# Сбросим файл __page.opt
WikiDocument.clearConfigFile (path)
# Теперь ошибок быть не должно
WikiDocument.load (path)
removeWiki (path)
def setUp (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self._exampleStyleDir = u"../styles/example_jblog"
self._exampleStyleDir2 = u"../styles/example_jnet"
wiki = WikiDocument.create (self.path)
factory = TextPageFactory()
factory.create (wiki, u"Страница 1", [])
factory.create (wiki, u"Страница 2", [])
factory.create (wiki[u"Страница 2"], u"Страница 3", [])
factory.create (wiki[u"Страница 2/Страница 3"], u"Страница 4", [])
factory.create (wiki[u"Страница 1"], u"Страница 5", [])
factory.create (wiki, u"страница 4", [])
filesPath = u"../test/samplefiles/"
files = [u"accept.png", u"add.png", u"anchor.png"]
fullFilesPath = [os.path.join (filesPath, fname) for fname in files]
Attachment (wiki[u"Страница 4"]).attach (fullFilesPath)
Attachment (wiki[u"Страница 1/Страница 5"]).attach (fullFilesPath)
self.wiki = WikiDocument.load (self.path, readonly=True)
def testLoad(self):
path = u"../test/samplewiki"
Application.onTreeUpdate += self.treeUpdate
self.assertFalse(self.isTreeUpdate)
WikiDocument.load(path)
self.assertFalse(self.isTreeUpdate)
self.assertEqual(self.treeUpdateSender, None)
self.assertEqual(self.treeUpdateCount, 0)
Application.onTreeUpdate -= self.treeUpdate
def testLoad_02 (self):
path = u"../test/samplewiki"
Application.getEvent ('onTreeUpdate').bind (self.treeUpdate)
self.assertFalse(self.isTreeUpdate)
WikiDocument.load (path)
self.assertFalse (self.isTreeUpdate)
self.assertEqual (self.treeUpdateSender, None)
self.assertEqual (self.treeUpdateCount, 0)
Application.getEvent ('onTreeUpdate').unbind (self.treeUpdate)
def testReadOnly (self):
wikiReadOnly = WikiDocument.load (self.path, readonly=True)
Application.wikiroot = wikiReadOnly
Application.selectedPage = wikiReadOnly[u"Страница 1"]
self._tabsController.cloneTab()
self._tabsController.openInTab (wikiReadOnly[u"Страница 2"], True)
self.assertEqual (self._tabsController.getTabsCount(), 3)
# Загрузим вики еще раз, чтобы убедиться, что состояние вкладок мы не поменяли
otherwiki = WikiDocument.load (self.path, readonly=True)
Application.wikiroot = otherwiki
self.assertEqual (self._tabsController.getTabsCount(), 1)
self.assertEqual (Application.selectedPage, None)
def testSaveTabs5(self):
wiki = WikiDocument.load(self.wikiroot.path)
self.application.wikiroot = wiki
self.application.selectedPage = wiki["Страница 1"]
self._tabsController.cloneTab()
self._tabsController.openInTab(wiki["Страница 2"], True)
self.assertEqual(self._tabsController.getTabsCount(), 3)
# Загрузим вики еще раз, чтобы убедиться, что состояние вкладок мы не поменяли
otherwiki = WikiDocument.load(self.wikiroot.path)
self.application.wikiroot = otherwiki
self.assertEqual(self._tabsController.getTabsCount(), 3)
self.assertEqual(self.application.selectedPage, otherwiki["Страница 2"])
def createNewWiki(parentwnd):
"""
Создать новую вики
parentwnd - окно-владелец диалога выбора файла
"""
dlg = TestedFileDialog(parentwnd, style=wx.FD_SAVE)
newPageTitle = _(u"First Wiki Page")
newPageContent = _(u"""!! First Wiki Page
This is the first page. You can use a text formatting: '''bold''', ''italic'', {+underlined text+}, [[https://jenyay.net | link]] and others.""")
if dlg.ShowModal() == wx.ID_OK:
try:
from outwiker.pages.wiki.wikipage import WikiPageFactory
newwiki = WikiDocument.create(dlg.GetPath())
WikiPageFactory().create(newwiki, newPageTitle, [_(u"test")])
firstPage = newwiki[newPageTitle]
firstPage.content = newPageContent
Application.wikiroot = newwiki
Application.wikiroot.selectedPage = firstPage
except (IOError, OSError) as e:
# TODO: проверить под Windows
showError(Application.mainWindow, _(u"Can't create wiki\n") + e.filename)
dlg.Destroy()
def testLoadingOldVersion2(self):
"""
Тест на чтение вики старой версии, когда еще не было параметра order
"""
TextPageFactory().create(self.wikiroot, u"Страница 1", [])
TextPageFactory().create(self.wikiroot, u"Страница 0", [])
TextPageFactory().create(self.wikiroot, u"Страница 3", [])
TextPageFactory().create(self.wikiroot, u"Страница 2", [])
# Удалим параметры order
IntegerOption(self.wikiroot[u"Страница 0"].params,
PageConfig.sectionName,
PageConfig.orderParamName, -1).remove_option()
IntegerOption(self.wikiroot[u"Страница 1"].params,
PageConfig.sectionName,
PageConfig.orderParamName, -1).remove_option()
IntegerOption(self.wikiroot[u"Страница 2"].params,
PageConfig.sectionName,
PageConfig.orderParamName, -1).remove_option()
IntegerOption(self.wikiroot[u"Страница 3"].params,
PageConfig.sectionName,
PageConfig.orderParamName, -1).remove_option()
wikiroot = WikiDocument.load(self.path)
self.assertEqual(wikiroot[u"Страница 0"].order, 0)
self.assertEqual(wikiroot[u"Страница 1"].order, 1)
self.assertEqual(wikiroot[u"Страница 2"].order, 2)
self.assertEqual(wikiroot[u"Страница 3"].order, 3)
def test_alias_readonly_01(self):
newwiki = WikiDocument.load(self.path, readonly=True)
page = newwiki[u'Страница 1']
self.assertRaises(ReadonlyException,
self._changeAlias,
page, u'Тест')
def __createWiki (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
WikiPageFactory().create (self.wikiroot, u"Страница 2", [])
self.testPage = self.wikiroot[u"Страница 2"]
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 __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u"Абырвалг абыр")
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]
self.attach_page2 = Attachment(self.wikiroot[u"Страница 2"])
# Прикрепим к двум страницам файлы
Attachment(self.testPage).attach(fullFilesPath)
def testReloading (self):
attach = Attachment (self.page)
attach.attach (self.fullFilesPath)
self.wikiroot.selectedPage = self.page
Application.wikiroot = self.wikiroot
self.assertEqual (self.wnd.attachPanel.panel.attachList.GetItemCount(), len (self.fullFilesPath))
# Создадим другую независимую вики
newpath = u"../test/testwiki2"
newwikiroot = WikiDocument.create (newpath)
TextPageFactory.create (newwikiroot, u"Новая страница 1", [])
TextPageFactory.create (newwikiroot, u"Новая страница 2", [])
filesPath = u"../test/samplefiles/"
newfiles = [u"accept.png", u"add.png", u"anchor.png"]
newfullFilesPath = [os.path.join (filesPath, fname) for fname in newfiles]
newattach = Attachment (newwikiroot[u"Новая страница 1"])
newattach.attach (newfullFilesPath)
newwikiroot.selectedPage = newwikiroot[u"Новая страница 1"]
Application.wikiroot = newwikiroot
self.assertEqual (self.wnd.attachPanel.panel.attachList.GetItemCount(), len (newfullFilesPath))
Application.wikiroot.selectedPage = None
Application.wikiroot = None
removeWiki (newpath)
def testAutoLineWrapRename (self):
self.rootwiki[u"Страница 1"].autoLineWrap = False
self.rootwiki[u"Страница 1"].title = u"Страница 666"
self.assertFalse (self.rootwiki[u"Страница 666"].autoLineWrap)
wiki = WikiDocument.load (self.path)
self.assertFalse (wiki[u"Страница 666"].autoLineWrap)
def testEmptyContent (self):
"""
Тест страницы без файла контента
"""
wiki = WikiDocument.load (path)
page = wiki[u"Страница без контента"]
self.assertEqual (page.content, "")
def setUp(self):
# Здесь будет создаваться вики
self.path = u"../test/testwiki"
removeWiki (self.path)
self.eventcount = 0
self.rootwiki = WikiDocument.create (self.path)
TextPageFactory.create (self.rootwiki, u"Страница 1", [])
TextPageFactory.create (self.rootwiki, u"Страница 2", [])
TextPageFactory.create (self.rootwiki[u"Страница 2"], u"Страница 3", [])
TextPageFactory.create (self.rootwiki[u"Страница 2/Страница 3"], u"Страница 4", [])
TextPageFactory.create (self.rootwiki[u"Страница 1"], u"Страница 5", [])
self.rootwiki[u"Страница 1"].content = u"1234567"
self.rootwiki[u"Страница 2/Страница 3"].content = u"Абырвалг"
self.rootwiki[u"Страница 2/Страница 3/Страница 4"].content = u"Тарам-пам-пам"
self.rootwiki[u"Страница 1/Страница 5"].content = u"111111"
self.rootwiki[u"Страница 1"].tags = [u"метка 1"]
self.rootwiki[u"Страница 2/Страница 3"].tags = [u"метка 2", u"метка 3"]
self.rootwiki[u"Страница 2/Страница 3/Страница 4"].tags = [u"метка 1", u"метка 2", u"метка 4"]
self.rootwiki[u"Страница 2/Страница 3/Страница 4"].icon = "../test/images/feed.gif"
self.icons = ["../test/images/icon.gif",
"../test/images/icon.png",
"../test/images/icon.jpg",
"../test/images/icon.ico"]
Application.wikiroot = None
def __export (self,
page,
root,
outdir,
imagesonly,
alwaysOverwrite):
"""
page - страница, начиная с которой надо начать экспортирование
root - корневая страница, откуда началось общее экспортирование (для определения имени файлов)
outdir - директория для экспорта
imagesonly - из вложений оставлять только картинки?
alwaysOverwrite - перезаписывать существующие файлы?
"""
if page.getTypeString() != WikiDocument.getTypeString():
try:
exporter = ExporterFactory.getExporter (page)
exportname = self.__nameGenerator.getName (page)
self.__renames[page] = exportname
exporter.export (outdir, exportname, imagesonly, alwaysOverwrite)
except BaseException as error:
self.__log.append (u"{0}: {1}".format (page.title, str(error)))
for child in page.children:
self.__export (
child,
root,
outdir,
imagesonly,
alwaysOverwrite)
def testSelection5 (self):
self.rootwiki.selectedPage = self.rootwiki[u"Страница 2/Страница 3"]
self.rootwiki[u"Страница 2"].remove()
wiki2 = WikiDocument.load (self.path)
self.assertEqual (wiki2.selectedPage, None)
def setUp(self):
# Количество срабатываний особытий при обновлении страницы
self.treeUpdateCount = 0
self.treeUpdateSender = None
Application.wikiroot = None
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
factory = TextPageFactory()
factory.create (self.wikiroot, u"Страница 8", [])
factory.create (self.wikiroot, u"Страница 2", [])
factory.create (self.wikiroot, u"Страница 5", [])
factory.create (self.wikiroot, u"Страница 4", [])
factory.create (self.wikiroot, u"Страница 6", [])
factory.create (self.wikiroot, u"Страница 1", [])
factory.create (self.wikiroot, u"Страница 3", [])
factory.create (self.wikiroot, u"Страница 7", [])
self.wikiroot[u"Страница 8"].order = 0
self.wikiroot[u"Страница 2"].order = 1
self.wikiroot[u"Страница 5"].order = 2
self.wikiroot[u"Страница 4"].order = 3
self.wikiroot[u"Страница 6"].order = 4
self.wikiroot[u"Страница 1"].order = 5
self.wikiroot[u"Страница 3"].order = 6
self.wikiroot[u"Страница 7"].order = 7
def testNotPage (self):
"""
Тест папок, которые не являются страницами
"""
wiki = WikiDocument.load (path)
page = wiki[u"Просто папка"]
self.assertEqual (page, None)
def threadFunc (path, readonly):
try:
return WikiDocument.load (path, readonly)
except IOError as error:
return error
except outwiker.core.exceptions.RootFormatError as error:
return error
def testRestoreReadonly_02(self):
from sessions.sessioncontroller import SessionController
wiki = WikiDocument.load(self.wikiroot.path, readonly=True)
self.application.wikiroot = wiki
self.application.selectedPage = wiki["Страница 1"]
tabsController = self.application.mainWindow.tabsController
tabsController.openInTab(wiki["Страница 2"], True)
tabsController.openInTab(wiki["Страница 1/Страница 3/Страница 4"],
True)
tabsController.openInTab(wiki["Страница 1/Страница 3"], False)
controller = SessionController(self.application)
session = controller.getCurrentSession()
tabsController.closeTab(1)
tabsController.closeTab(1)
tabsController.closeTab(1)
controller.restore(session)
self.assertEqual(os.path.abspath(self.application.wikiroot.path),
os.path.abspath(self.wikiroot.path))
self.assertTrue(self.application.wikiroot.readonly)
self.assertEqual(os.path.abspath(self.application.wikiroot.path),
os.path.abspath(self.wikiroot.path))
self.assertEqual(tabsController.getTabsCount(), 4)
self.assertEqual(tabsController.getSelection(), 2)
self.assertEqual(tabsController.getPage(0).title, "Страница 1")
self.assertEqual(tabsController.getPage(1).title, "Страница 2")
self.assertEqual(tabsController.getPage(2).title, "Страница 4")
self.assertEqual(tabsController.getPage(3).title, "Страница 3")
def testRestore_05(self):
from sessions.sessioncontroller import SessionController
self.__createWiki2()
wiki2 = WikiDocument.load(self.path2, True)
self.application.wikiroot = self.wikiroot
self.application.selectedPage = self.wikiroot["Страница 1"]
tabsController = self.application.mainWindow.tabsController
tabsController.openInTab(self.wikiroot["Страница 2"], True)
controller = SessionController(self.application)
session = controller.getCurrentSession()
uid1 = self._getPageLink(self.wikiroot["Страница 1"])
uid2 = self._getPageLink(self.wikiroot["Страница 2"])
self.application.wikiroot = wiki2
self.assertEqual(tabsController.getTabsCount(), 1)
controller.restore(session)
self.assertEqual(os.path.abspath(self.application.wikiroot.path),
os.path.abspath(self.wikiroot.path))
self.assertEqual(tabsController.getTabsCount(), 2)
self.assertEqual(tabsController.getSelection(), 1)
newsession = controller.getCurrentSession()
self.assertEqual(newsession.pages[0], uid1)
self.assertEqual(newsession.pages[1], uid2)
def testSaveSession_06(self):
from sessions.sessionstorage import SessionStorage
from sessions.sessioncontroller import SessionController
tabsController = self.application.mainWindow.tabsController
uid1 = self._getPageLink(self.wikiroot["Страница 1"])
uid2 = self._getPageLink(self.wikiroot["Страница 2"])
wiki = WikiDocument.load(self.wikiroot.path, True)
self.application.wikiroot = wiki
self.application.selectedPage = wiki["Страница 1"]
tabsController.openInTab(wiki["Страница 2"], True)
sessionName = "Имя сессии"
controller = SessionController(self.application)
session = controller.getCurrentSession()
# Сохраним сессию дважды под одним и тем же именем
SessionStorage(self.application.config).save(session, sessionName)
SessionStorage(self.application.config).save(session, sessionName)
otherStorage = SessionStorage(self.application.config)
sessions = otherStorage.getSessions()
self.assertEqual(len(sessions), 1)
self.assertEqual(len(sessions[sessionName].pages), 2)
self.assertEqual(sessions[sessionName].pages[0], uid1)
self.assertEqual(sessions[sessionName].pages[1], uid2)
self.assertEqual(sessions[sessionName].currentTab, 1)
self.assertTrue(sessions[sessionName].readonly)
def setUp(self):
# Здесь будет создаваться вики
self.path = os.path.realpath (u"../test/testwiki")
removeWiki (self.path)
self.rootwiki = WikiDocument.create (self.path)
# - Страница 1
# - # Страница 5
# - Страница 6
# - Страница 2
# - Страница 3
# - # Страница 4
WikiPageFactory.create (self.rootwiki, u"Страница 1", [])
WikiPageFactory.create (self.rootwiki, u"Страница 2", [])
WikiPageFactory.create (self.rootwiki[u"Страница 2"], u"Страница 3", [])
WikiPageFactory.create (self.rootwiki[u"Страница 2/Страница 3"], u"# Страница 4", [])
WikiPageFactory.create (self.rootwiki[u"Страница 1"], u"# Страница 5", [])
WikiPageFactory.create (self.rootwiki[u"Страница 1"], u"Страница 6", [])
WikiPageFactory.create (self.rootwiki[u"Страница 1/# Страница 5"], u"Страница 7", [])
filesPath = u"../test/samplefiles/"
self.files = [u"accept.png", u"add.png", u"anchor.png", u"файл с пробелами.tmp", u"dir"]
self.fullFilesPath = [os.path.join (filesPath, fname) for fname in self.files]
Attachment (self.rootwiki[u"Страница 1"]).attach (self.fullFilesPath)
Attachment (self.rootwiki[u"Страница 1/# Страница 5"]).attach (self.fullFilesPath)
Application.wikiroot = None
def testLoadContent(self):
from webpage.webnotepage import WebPageFactory
wikiroot = WikiDocument.create(self.path)
test_page = WebPageFactory().create(wikiroot, "Страница 1", [])
test_page.content = "Абырвалг"
self.application.wikiroot = wikiroot
self.application.selectedPage = test_page
pageview = self.application.mainWindow.pagePanel.pageView
pageContent = pageview.codeEditor.GetText()
self.assertEqual(pageContent, "Абырвалг")
def __createInvalidWiki1():
# Здесь будет создаваться вики
path = mkdtemp(prefix='Абырвалг абыр')
rootwiki = WikiDocument.create(path)
factory = TextPageFactory()
factory.create(rootwiki, "Страница 1", [])
factory.create(rootwiki["Страница 1"], "Страница 2", [])
# Испортим файл __page.opt
with open(os.path.join(rootwiki.path, "__page.opt"), "w") as fp:
fp.write("wsfsdf sdf sdfasdfdsf \nasfasdsadf")
return path
def setUp(self):
self.thumbmaker = PageThumbmaker()
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = TextPageFactory()
factory.create(self.wikiroot, u"Страница 1", [])
factory.create(self.wikiroot, u"Страница 2", [])
factory.create(self.wikiroot[u"Страница 2"], u"Страница 3", [])
factory.create(self.wikiroot[u"Страница 2/Страница 3"], u"Страница 4",
[])
factory.create(self.wikiroot[u"Страница 1"], u"Страница 5", [])
def testLoading3(self):
TextPageFactory().create(self.wikiroot, "Страница 0", [])
TextPageFactory().create(self.wikiroot, "Страница 1", [])
TextPageFactory().create(self.wikiroot, "Страница 2", [])
TextPageFactory().create(self.wikiroot, "Страница 3", [])
self.wikiroot["Страница 0"].order += 1
self.wikiroot["Страница 3"].order -= 1
wikiroot = WikiDocument.load(self.path)
self.assertEqual(wikiroot["Страница 1"].order, 0)
self.assertEqual(wikiroot["Страница 0"].order, 1)
self.assertEqual(wikiroot["Страница 3"].order, 2)
self.assertEqual(wikiroot["Страница 2"].order, 3)
def testChangeContent(self):
plugin = self.loader["TestPage"]
wikiroot = WikiDocument.create(self.wikiroot.path)
test_page = plugin.TestPageFactory().create(wikiroot, "Страница 1", [])
test_page.content = "Абырвалг"
self.application.wikiroot = wikiroot
self.application.selectedPage = test_page
pageview = self.application.mainWindow.pagePanel.pageView
pageview.text.SetValue("Бла-бла-бла")
self.application.selectedPage = None
self.application.wikiroot = None
wikiroot_other = WikiDocument.load(self.wikiroot.path)
self.application.wikiroot = wikiroot_other
self.application.selectedPage = wikiroot_other["Страница 1"]
pageview = self.application.mainWindow.pagePanel.pageView
pageContent = pageview.text.GetValue()
self.assertEqual(pageContent, "Бла-бла-бла")
def testLoadSearchPage(self):
GlobalSearch.create(self.wikiroot,
phrase="декабрь",
tags=["Метка 1", "Метка 2"],
strategy=AllTagsSearchStrategy)
wiki = WikiDocument.load(self.path)
page = wiki[GlobalSearch.pageTitle]
self.assertNotEqual(page, None)
self.assertEqual(page.phrase, "декабрь")
self.assertEqual(len(page.searchTags), 2)
self.assertTrue("Метка 1" in page.searchTags)
self.assertTrue("Метка 2" in page.searchTags)
self.assertEqual(page.strategy, AllTagsSearchStrategy)
def testInvalidWikiRoot1(self):
"""
Тест на обработку ошибки в файле __page.opt корня вики
"""
def __createInvalidWiki1():
# Здесь будет создаваться вики
path = mkdtemp(prefix='Абырвалг абыр')
rootwiki = WikiDocument.create(path)
factory = TextPageFactory()
factory.create(rootwiki, "Страница 1", [])
factory.create(rootwiki["Страница 1"], "Страница 2", [])
# Испортим файл __page.opt
with open(os.path.join(rootwiki.path, "__page.opt"), "w") as fp:
fp.write("wsfsdf sdf sdfasdfdsf \nasfasdsadf")
return path
path = __createInvalidWiki1()
WikiDocument.load(path)
removeDir(path)
def testCreateEvent(self):
Application.onTreeUpdate += self.treeUpdate
Application.onPageCreate += self.pageCreate
removeDir(self.path)
self.assertFalse(self.isTreeUpdate)
self.assertFalse(self.isPageUpdate)
self.assertFalse(self.isPageCreate)
# Создаем вики
rootwiki = WikiDocument.create(self.path)
self.assertFalse(self.isTreeUpdate)
self.assertEqual(self.treeUpdateSender, None)
Application.wikiroot = rootwiki
# Создаем страницу верхнего уровня (не считая корня)
self.isPageCreate = False
self.pageCreateSender = None
TextPageFactory().create(rootwiki, u"Страница 1", [])
self.assertTrue(self.isPageCreate)
self.assertEqual(self.pageCreateSender, rootwiki[u"Страница 1"])
# Создаем еще одну страницу
self.isPageCreate = False
self.pageCreateSender = None
TextPageFactory().create(rootwiki, u"Страница 2", [])
self.assertTrue(self.isPageCreate)
self.assertEqual(self.pageCreateSender, rootwiki[u"Страница 2"])
# Создаем подстраницу
self.isPageCreate = False
self.pageCreateSender = None
TextPageFactory().create(rootwiki[u"Страница 2"], u"Страница 3", [])
self.assertTrue(self.isPageCreate)
self.assertEqual(self.pageCreateSender,
rootwiki[u"Страница 2/Страница 3"])
Application.onTreeUpdate -= self.treeUpdate
Application.onPageCreate -= self.pageCreate
def testLoadContent(self):
plugin = self.loader[u"TestPage"]
wikiroot = WikiDocument.create(self.path)
test_page = plugin.TestPageFactory().create(wikiroot, u"Страница 1",
[])
test_page.content = u"Абырвалг"
Application.wikiroot = wikiroot
Application.selectedPage = test_page
pageview = Application.mainWindow.pagePanel.pageView
pageContent = pageview.text.GetValue()
self.assertEqual(pageContent, u"Абырвалг")
def setUp(self):
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
WikiPageFactory().create(self.wikiroot, "Страница 1", [])
self.testPage = self.wikiroot["Страница 1"]
filesPath = "../test/samplefiles/"
self.files = [
"accept.png", "add.png", "first.jpg", "image.jpeg",
"файл с пробелами.tmp"
]
self.fullFilesPath = [
os.path.join(filesPath, fname) for fname in self.files
]
def testCreateOrder8(self):
TextPageFactory().create(self.wikiroot, "Плагины", [])
TextPageFactory().create(self.wikiroot, "Абырвалг", [])
TextPageFactory().create(self.wikiroot, "Тест", [])
self.assertEqual(self.wikiroot["Плагины"].order, 0)
self.assertEqual(self.wikiroot["Абырвалг"].order, 1)
self.assertEqual(self.wikiroot["Тест"].order, 2)
self.wikiroot["Абырвалг"].title = "Ррррр"
wiki = WikiDocument.load(self.path)
self.assertEqual(wiki["Плагины"].order, 0)
self.assertEqual(wiki["Ррррр"].order, 1)
self.assertEqual(wiki["Тест"].order, 2)
def __createWiki(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = WikiPageFactory()
factory.create(self.wikiroot, u"Страница 1", [])
time.sleep(0.1)
factory.create(self.wikiroot[u"Страница 1"], u"Страница 2", [])
time.sleep(0.1)
factory.create(self.wikiroot[u"Страница 1"], u"Страница 4", [])
time.sleep(0.1)
factory.create(self.wikiroot[u"Страница 1"], u"СТРАНИЦА 3", [])
self.testPage = self.wikiroot[u"Страница 1"]
def setUp (self):
self.path = mkdtemp (prefix=u'Абырвалг абыр')
Application.wikiroot = None
self.wikiroot = WikiDocument.create (self.path)
factory = TextPageFactory()
factory.create (self.wikiroot, u"Страница 1", [])
factory.create (self.wikiroot, u"Страница 2", [])
factory.create (self.wikiroot[u"Страница 2"], u"Страница 3", [])
factory.create (self.wikiroot[u"Страница 2/Страница 3"], u"Страница 4", [])
factory.create (self.wikiroot[u"Страница 1"], u"Страница 5", [])
factory.create (self.wikiroot, u"Страница 6", [])
self.pageRemoveCount = 0
Application.wikiroot = None
def testTags(self):
wiki = WikiDocument.load(self.path)
self.assertTrue("метка 1" in wiki["Страница 1"].tags)
self.assertEqual(len(wiki["Страница 1"].tags), 1)
self.assertIn("метка 2", wiki["Страница 2/Страница 3"].tags)
self.assertIn("метка 3", wiki["Страница 2/Страница 3"].tags)
self.assertEqual(len(wiki["Страница 2/Страница 3"].tags), 2)
self.assertIn("метка 1", wiki["Страница 2/Страница 3/Страница 4"].tags)
self.assertIn("метка 2", wiki["Страница 2/Страница 3/Страница 4"].tags)
self.assertIn("метка 4", wiki["Страница 2/Страница 3/Страница 4"].tags)
self.assertEqual(len(wiki["Страница 2/Страница 3/Страница 4"].tags), 3)
def testSetPageParams(self):
param = StringOption(self.wikiroot["Страница 1"].params,
"TestSection_1", "value1", "")
param.value = "Значение 1"
param2 = StringOption(self.wikiroot["Страница 1"].params,
"TestSection_1", "value1", "")
self.assertEqual(param.value, "Значение 1")
self.assertEqual(param2.value, "Значение 1")
# Прочитаем вики и проверим установленный параметр
wiki = WikiDocument.load(self.path)
param3 = StringOption(wiki["Страница 1"].params, "TestSection_1",
"value1", "")
self.assertEqual(param3.value, "Значение 1")
def setUp(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = TextPageFactory()
factory.create(self.wikiroot, "page 1", ["Метка 1", "Метка 2"])
factory.create(self.wikiroot, "Страница 2", ["Метка 1", "Метка 3"])
factory.create(self.wikiroot["Страница 2"],
"Страница 3",
["Метка 2"])
factory.create(self.wikiroot["Страница 2/Страница 3"],
"Страница 4",
["Метка 1"])
factory.create(self.wikiroot["page 1"], "page 5", ["Метка 4"])
def setUp(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = TextPageFactory()
factory.create(self.wikiroot, "Страница 1", [])
factory.create(self.wikiroot, "Страница 2", [])
factory.create(self.wikiroot["Страница 2"], "Страница 3", [])
factory.create(self.wikiroot["Страница 2/Страница 3"],
"Страница 4",
[])
factory.create(self.wikiroot["Страница 1"], "Страница 5", [])
Application.wikiroot = None
def setUp(self):
# Количество срабатываний особытий при обновлении страницы
self.pageUpdateCount = 0
self.pageUpdateSender = None
# Здесь будет создаваться вики
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
Application.wikiroot = self.wikiroot
factory = TextPageFactory()
factory.create(self.wikiroot, "Страница 1", [])
factory.create(self.wikiroot, "Страница 2", [])
factory.create(self.wikiroot["Страница 2"], "Страница 3", [])
factory.create(self.wikiroot["Страница 2/Страница 3"], "Страница 4", [])
factory.create(self.wikiroot["Страница 1"], "Страница 5", [])
def setUp(self):
# Здесь будет создаваться вики
self.path = mkdtemp(prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = TextPageFactory()
factory.create(self.wikiroot, u"Страница 1", [])
factory.create(self.wikiroot, u"Страница 2", [])
factory.create(self.wikiroot[u"Страница 2"], u"Страница 3", [])
factory.create(self.wikiroot[u"Страница 2/Страница 3"], u"Страница 4",
[])
factory.create(self.wikiroot[u"Страница 1"], u"Страница 5", [])
self.bookmarkCount = 0
self.bookmarkSender = None
Application.wikiroot = None
def testSaveAfterMove(self):
self.application.wikiroot = self.wikiroot
self.application.selectedPage = self.wikiroot["Страница 1"]
self._tabsController.cloneTab()
self._tabsController.openInTab(self.wikiroot["Страница 2"], True)
self.wikiroot["Страница 1"].moveTo(self.wikiroot["Страница 2"])
otherwiki = WikiDocument.load(self.wikiroot.path)
self.application.wikiroot = otherwiki
self.assertEqual(self._tabsController.getTabsCount(), 3)
self.assertEqual(self._tabsController.getPage(0),
otherwiki["Страница 2/Страница 1"])
self.assertEqual(self._tabsController.getPage(1),
otherwiki["Страница 2/Страница 1"])
self.assertEqual(self._tabsController.getPage(2),
otherwiki["Страница 2"])
def setUp(self):
super().setUp()
self._eventCount = 0
self._period_ms = 50
self._application = Application
self._application.onAttachListChanged += self._onAttachListChanged
# Path to path with files
self._sample_path = 'testdata/samplefiles'
# Path to wiki
self.path = mkdtemp(prefix='OutWiker AttachWatcherTest Тесты')
self.wikiroot = WikiDocument.create(self.path)
self.page_01 = TextPageFactory().create(self.wikiroot, "Страница 1",
[])
self.page_02 = TextPageFactory().create(self.wikiroot, "Страница 2",
[])
def setUp(self):
self.outputdir = "../test/temp"
self.pluginname = u"Export2Html"
self.path = u"../test/samplewiki"
self.root = WikiDocument.load(self.path)
dirlist = [u"../plugins/export2html"]
self.loader = PluginsLoader(Application)
self.loader.load(dirlist)
removeDir(self.outputdir)
os.mkdir(self.outputdir)
Application.wikiroot = None
def testManySearchPages2(self):
TextPageFactory().create(self.wikiroot, '# Search', [])
GlobalSearch.create(self.wikiroot,
phrase="декабрь",
tags=["Метка 1", "Метка 2"],
strategy=AllTagsSearchStrategy)
wiki = WikiDocument.load(self.path)
page = wiki['# Search' + " 2"]
self.assertNotEqual(page, None)
self.assertEqual(page.phrase, "декабрь")
self.assertEqual(len(page.searchTags), 2)
self.assertTrue("Метка 1" in page.searchTags)
self.assertTrue("Метка 2" in page.searchTags)
self.assertEqual(page.strategy, AllTagsSearchStrategy)
def setUp(self):
self.path = mkdtemp(prefix='Абырвалг абыр')
self.wikiroot = WikiDocument.create(self.path)
factory = TextPageFactory()
factory.create(self.wikiroot, "Страница 1", [])
factory.create(self.wikiroot, "Страница 2", [])
factory.create(self.wikiroot["Страница 2"], "Страница 3", [])
factory.create(self.wikiroot["Страница 2/Страница 3"], "Страница 4",
[])
factory.create(self.wikiroot["Страница 1"], "Страница 5", [])
factory.create(self.wikiroot, "Страница 6", [])
self.treeUpdateCount = 0
self.eventSender = None
Application.wikiroot = None
def testPageSelectCreateNoEvent(self):
Application.onPageSelect += self.pageSelect
removeDir(self.path)
rootwiki = WikiDocument.create(self.path)
TextPageFactory().create(rootwiki, u"Страница 1", [])
TextPageFactory().create(rootwiki, u"Страница 2", [])
TextPageFactory().create(rootwiki[u"Страница 2"], u"Страница 3", [])
Application.wikiroot = rootwiki
self.assertEqual(rootwiki.selectedPage, None)
rootwiki.selectedPage = rootwiki[u"Страница 1"]
self.assertEqual(rootwiki.selectedPage, rootwiki[u"Страница 1"])
self.assertEqual(self.isPageSelect, True)
def testEmptyAttaches2(self):
"""
Попытка прикрепления файлов к странице без папки __attach
"""
filesPath = "testdata/samplefiles/"
files = ["accept.png", "add.png", "anchor.png"]
attaches = [os.path.join(filesPath, fname) for fname in files]
wiki = WikiDocument.load(self.path)
Attachment(wiki["Страница без аттачей"]).attach(attaches)
self.assertEqual(
len(Attachment(wiki["Страница без аттачей"]).attachmentFull), 3)
# Удалим прикрепленные файлы
attachPath = Attachment(wiki["Страница без аттачей"]).getAttachPath()
shutil.rmtree(attachPath)
wiki["Страница без аттачей"].datetime = self.defaultdate
def __createInvalidWiki2():
# Здесь будет создаваться вики
path = mkdtemp(prefix=u'Абырвалг абыр')
removeDir(path)
rootwiki = WikiDocument.create(path)
factory = TextPageFactory()
factory.create(rootwiki, u"Страница 1", [])
factory.create(rootwiki[u"Страница 1"], u"Страница 2", [])
# Испортим файл __page.opt
with open(os.path.join(rootwiki.path, u"__page.opt"), "w") as fp:
fp.write(
u"[General]\naaa=xxx\n<<<<<<<<wsfsdf sdf sdfasdfdsf \nasfasdsadf"
)
return path
def testCreate(self):
from webpage.webnotepage import WebPageFactory, WebNotePage
wikiroot = WikiDocument.create(self.path)
test_page = WebPageFactory().create(wikiroot, "Страница 1", [])
self.assertEqual(type(test_page), WebNotePage)
self.assertEqual(
type(FactorySelector.getFactory(WebNotePage.getTypeString())),
WebPageFactory)
self.loader.clear()
self.assertEqual(type(FactorySelector.getFactory(WebNotePage.getTypeString())),
UnknownPageTypeFactory)
self.loader.load(self.dirlist)
self.assertEqual(type(FactorySelector.getFactory(WebNotePage.getTypeString())),
WebPageFactory)
def setUp (self):
# Количество срабатываний особытий при обновлении страницы
self.pageUpdateCount = 0
self.pageUpdateSender = None
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
self.wikiroot = WikiDocument.create (self.path)
TextPageFactory().create (self.wikiroot, u"Страница 1", [])
self.page = self.wikiroot[u"Страница 1"]
filesPath = u"../test/samplefiles/"
self.files = [u"accept.png", u"add.png", u"anchor.png", u"файл с пробелами.tmp", u"dir"]
self.fullFilesPath = [os.path.join (filesPath, fname) for fname in self.files]
self.prev_kwargs = None
Application.wikiroot = self.wikiroot
def __createWiki (self):
# Здесь будет создаваться вики
self.path = mkdtemp (prefix=u'Абырвалг абыр')
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]
self.attach_page2 = Attachment (self.wikiroot[u"Страница 2"])
# Прикрепим к двум страницам файлы
Attachment (self.testPage).attach (fullFilesPath)
