def testInit(self):
from file_system import FileSystem
from system import System, system
fileSystem = FileSystem()
print IceCommon.openOfficeName
IceCommon.setup(system, fileSystem)
def setUp(self):
# Make/setup self.sRep (with a basePath of tempRepPath)
# Also set self.__fs to tempRepPath
if self.recreateFSRep:
removeTempFSRep()
createTempFSRep()
if IceCommon.system.isWindows:
global tempRepPath
tempRepPath = tempfile.mkdtemp()
self.client = pysvn.Client()
if self.recreateTempRep:
removeTempRep()
self.client.checkout(url=tempFSRepUrl + "/TestRep",
path=tempRepPath,
recurse=True)
iceContext = IceCommon.IceContext
self.rep = MockRep(IceCommon.FileSystem(tempRepPath))
iceContext.rep = self.rep
self.sRep = SvnRep(iceContext,
basePath=tempRepPath,
svnUrl=tempFSRepUrl + "/TestRep")
if self.recreateTempRep == False:
self.revert()
self.fs = IceCommon.FileSystem(tempRepPath)
def xtestObjectReplacementHack(self):
buildTestFile = True
fs = FileSystem(".")
converter = oooConverter()
fromBookFile = noMathtype
toBookFile = "testData/testObjectReplacementHackResult.odt"
fs.delete(toBookFile)
self.assertFalse(fs.isFile(toBookFile))
docs = [ (sample_mathtype, ""), (noMathtype, ""), \
(sample_mathtypeAndNoMathType, ""), (linkfile, "") ]
try:
# build test infomation
converter.buildBook(fromBookFile,
docs,
toBookFile,
baseUrl="http://localhost:8000",
title=None)
self.assertTrue(fs.isFile(toBookFile))
xmlString = """<root
xmlns:draw='urn:oasis:names:tc:opendocument:xmlns:drawing:1.0'
xmlns:xlink='http://www.w3.org/1999/xlink'
xmlns:text='urn:oasis:names:tc:opendocument:xmlns:text:1.0'
xmlns:svg='urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0'>"""
# now assert the the toBookFile contains all the orginal enbedded objects.
tempFs = fs.unzipToTempDirectory(toBookFile)
xml = IceCommon.Xml(tempFs.absolutePath("content.xml"), nsList)
nodes = xml.getNodes("//draw:frame")
if buildTestFile == True:
print "Building expectedxmlString.xml"
for node in nodes:
xmlString += str(node)
xmlString += "</root>"
fs.writeFile("testData/expectedxmlString.xml", xmlString)
else:
#Compare current Book xml with the expected xml result
xmlExpected = IceCommon.Xml("testData/expectedxmlString.xml",
nsList)
expectedNodes = xmlExpected.getNodes("//draw:frame")
for node, expectedNode in zip(nodes, expectedNodes):
#Hack: for now just remove namespaces for testing
nodeStr = str(node).replace(":", "_")
expectedNodeStr = str(expectedNode).replace(":", "_")
self.assertSameXml(nodeStr, expectedNodeStr, \
"Nodes are not the same!")
xmlExpected.close()
finally:
xml.close()
tempFs.delete()
def test_getPreviousItem():
print "test_getPreviousItem()"
mockOrg = mockOrganization()
xml = IceCommon.Xml(nestedItemTestXml)
nestedItemTestNode = xml.getRootNode()
item = imsItem(mockOrg, itemXmlNode=nestedItemTestNode)
mockOrg.addItem(item)
xml.close()
print "===="
print mockOrg.__class__.__name__
print mockOrg.parentItem
print mockOrg
print "===="
aItem = item.getNextItem().getNextItem()
print "aItem=", aItem.title
prevItem = aItem.getPreviousItem()
print "prevItem=", prevItem.title
assert prevItem.title == "Module 1 About Stuff"
prevItem = prevItem.getPreviousItem()
print "prevItem=", prevItem.title
assert prevItem.title == "Study Guide"
print "---"
print prevItem.__class__.__name__
print prevItem.parentItem
print "---"
prevItem = prevItem.getPreviousItem()
print prevItem
print "-----"
def testAssertSameXml(self):
xmlStr1 = "<root><item a='2' b='1'/></root>"
xmlStr2 = "<root><item b=\"1\" a='2'></item></root>"
xmlStr3 = "<root><item a='2' b='11'/></root>"
t = self.test
# should assert to being the same
t.assertSameXml("<root/>", "<root></root>")
t.assertSameXml(xmlStr1, xmlStr2)
xml = IceCommon.Xml(xmlStr1)
t.assertSameXml(xml, xmlStr1)
t.assertSameXml(xml, xmlStr2)
t.assertSameXml(xmlStr2, xml)
xml.close()
# should raise an AssertionError
msg = self.__expectAssertionError(None, None)
expectedMsg = 'Xml not the same!\n\t(not XML data) actual==None and expected==None!'
self.assertEqual(msg, expectedMsg)
#print repr(msg)
msg = self.__expectAssertionError("", "")
expectedMsg = 'Xml not the same!\n\tActual is not well-formed XML! (or is not an xmlString or dom/node)'
self.assertEqual(msg, expectedMsg)
#print repr(msg)
msg = self.__expectAssertionError(None, "<root/>")
expectedMsg = 'Xml not the same!\n\tactual==None and actual!=expected!'
self.assertEqual(msg, expectedMsg)
#print repr(msg)
msg = self.__expectAssertionError(xmlStr1, xmlStr3)
expectedMsg = 'Xml not the same!\n\t <root>\n\n- <item a="2" b="1"></item>\n\n+ <item a="2" b="11"></item>\n\n? +\n\n </root>\n\nactual = \'<root>\n <item a="2" b="1"></item>\n</root>\'\nexpected = \'<root>\n <item a="2" b="11"></item>\n</root>\''
self.assertEqual(msg, expectedMsg)
def xtestExternalLinkReport(self):
manifestItem = {"/": ["Package Title", 1, 0], "one.odt": ["One Title", 0, "one.htm"]}
rep = MockRep(self.iceContext, {"/one.htm":""}, {"/one.htm":{"http://www.python.org":"linkText"}}, manifest=manifestItem)
checker = CourseLinkCheck(self.iceContext)
report = checker.report("/")
# print report
# print "----"
dom = IceCommon.Xml(report)
try:
h1 = dom.getNode("//h1[1]")
h1msg = h1.getNextSibling().content
self.assertEqual(h1msg, "\nNo invalid internal links\n")
h1 = dom.getNode("//h1[2]")
#print str(h1)
nextSibling = h1.getNextSibling()
if nextSibling.getType()=="text":
nextSibling = nextSibling.getNextSibling()
listItem = nextSibling.getNode("li[1]")
#print str(listItem)
self.assertEqual(len(listItem.getNodes("a")), 1)
self.assertEqual(listItem.getNode("a/@href").content, "/one.htm")
#print h1msg
#self.assertEqual(h1msg, "No external links found")
finally:
dom.close()
def testProperties(self):
rep = self.getRep()
item = self.getItem(rep, relPath="testDir/test.odt")
data = IceCommon.fs.readFile(testOdt)
item.write(data)
self.assertEquals(item.relPath, "/testDir/test.odt")
self.assertTrue(item._propAbsPath.endswith("/testDir/.ice/test.odt"))
self.assertEquals(len(item.guid), 32)
self.assertFalse(item.convertFlag)
self.assertFalse(item.hasPdf)
self.assertFalse(item.hasHtml)
self.assertEquals(item.hasSlide, None)
self.assertFalse(item.needsUpdating)
self.assertEquals(item.tags, [])
self.assertEquals(item.inlineAnnotations, None)
self.assertEquals(item.bookInfo, None)
self.assertEquals(item.lastChangedRevisionNumber, -1)
self.assertFalse(item.isRenderable)
parent = item.parentItem
#setConvertedData()
cd = item.iceContext.ConvertedData()
cd.addMeta("title", "TestTitle")
cd.addRenditionData(".xhtml.body", "<div><p>TestPara</p></div>")
cd.addRenditionData(".pdf", "[PDF-DATA]")
item.setConvertedData(cd)
#item.hasHtml, item.hasPdf still both False
self.assertEquals(item.metaNames, ["title"])
self.assertEquals(item.getMeta("title"), "TestTitle")
self.assertEquals(item.getRendition(".pdf"), "[PDF-DATA]")
rep.serverData = IceCommon.Object()
def getIdForRelPath(relPath):
return 0x555
rep.serverData.getIdForRelPath = getIdForRelPath
self.assertEquals(item.getIdUrl(), "test_i555r-1.odt")
def iceWebServer(IceCommon, options, outputWriter):
iceContext = IceCommon.IceContext(options=options)
iceContext.loadRepositories()
settings = iceContext.settings
asServiceOnly = bool(
options.get("asserviceonly", settings.get("asServiceOnly", False)))
enableExternalAccess = bool(
options.get("enableexternalaccess",
settings.get("enableExternalAccess", False)))
port = int(options.get("port", options.get("p", iceContext.config.port)))
settings["asServiceOnly"] = asServiceOnly
settings["enableExternalAccess"] = enableExternalAccess
webserver = options.get("webserver", settings.get("webServer", "default"))
iceContext.isServer = options.get("server", settings.get("server", False))
settings["webserver"] = webserver
iceContext.config.setPort(str(port))
if asServiceOnly:
outputWriter("* asServiceOnly *\n")
if enableExternalAccess:
outputWriter("* external access enabled *\n")
if iceContext.isServer:
outputWriter("* running as a server!\n")
iceServer = IceServer(iceContext, IceRequest, ServerRequestData,
ServerResponseData)
iceServer.serve()
def test_load():
print "test_load()"
item = imsItem(mockOrg)
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
item.load(simpleItemTestNode)
assertSameXml(str(item), str(simpleItemTestNode))
xml.close()
xml = IceCommon.Xml(nestedItemTestXml)
nestedItemTestNode = xml.getRootNode()
item.load(nestedItemTestNode)
assertSameXml(str(item), str(nestedItemTestNode))
xml.close()
def test_serialize():
# serialize(xml) - (overriden)
org = getTestOrg()
xml = IceCommon.Xml("<root/>")
orgNode = org.serialize(xml)
assertSameXml(str(orgNode), organizationXmlStr)
xml.close()
def __init__(self, IceCommon):
self.fs = IceCommon.FileSystem(".")
self.system = system
self.xmlUtils = IceCommon.xmlUtils
self.rep = MockRep(self.fs)
self.isWindows = system.isWindows
self.isLinux = system.isLinux
self.isMac = system.isMac
def test_serialize():
print "test_serialize()"
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
item = imsItem(mockOrg, itemXmlNode=simpleItemTestNode)
node = item.serialize(xml)
assertSameXml(str(node), simpleItemTestXml)
xml.close()
def getTestOrg():
parent = mockParent()
org = imsOrganization(parent)
xml = IceCommon.Xml(organizationXmlStr)
node = xml.getRootNode()
org.load(node)
xml.close()
return org
def getRep(self):
iceContext = IceCommon.IceContext(None)
output = iceContext.output
iceContext.output = None
setupRep(self.fs)
rep = IceRepository(iceContext, testRep, repUrl=repUrl,
iceRender=MockIceRender(iceContext))
iceContext.output = output
return rep
def main(IceCommon, args, sys, outputWriter):
shortOptionNames = {"h":"help", "f":"file", "d":"directory", "dir":"directory",
"converter":"convert", "v":"verbose", "test":"testing"}
flags = ["help", "convert", "atompub", "atomconvertpub", "upgrade",
"verbose", "asserviceonly", "enableexternalaccess", "test"]
progName = args.pop(0)
options = IceCommon.getOptions(args, shortOptionNames, flags)
iceWebServer(IceCommon, options, outputWriter)
outputWriter("\n")
return 0
def processTest(name, xsltSrc, xmlSrc, expectedXml):
print "--- Test: '%s' ---" % name
xslt = xslt_util.xslt(xsltSrc)
r = "<root"
for ns in nsList:
r += " xmlns:" + ns[0] + '="' + ns[1] + '"\n'
r += ">\n"
r += xmlSrc + "\n</root>"
xml = IceCommon.Xml(r, nsList)
newXml = xml.applyXslt(xslt)
xslt.close()
xml.close()
expected = expectedXml.replace("utfx:expected",
"body").replace(' validate="no"', "")
html = """<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"></meta>
<title> Untitled </title>
<style type="text/css" xml:space="preserve">table {border-spacing: 0;empty-cells: show;} </style>
</head>
<body>
</body>
</html>"""
xml = IceCommon.Xml(expected, nsList)
import diff_util
same = diff_util.sameXml(newXml.getNode("//body"), xml.getNode("//body"),
False)
print "Same=", same
if same is False:
for node in newXml.getNode("//body").getChildren():
if node.getType() != "text":
print node
print
for node in xml.getNode("//body").getChildren():
if node.getType() != "text":
print node
newXml.close()
xml.close()
print "--- Done ---\n"
def test_load_serialize():
parent = mockParent()
orgs = imsOrganizations(parent)
xml = IceCommon.Xml(orgsXmlTestStr)
orgs.load(xml.getRootNode())
orgsNode = orgs.serialize(xml)
expected = """<organizations default="default"><mockOrganization identifier="default"/><mockOrganization identifier="test-id"/></organizations>"""
assertSameXml(orgsNode, expected)
xml.close()
def formatPart(xmlStr, match, format=True):
xml = IceCommon.Xml(xmlStr, [("", "http://www.w3.org/1999/xhtml"),
("html", "http://www.w3.org/1999/xhtml")])
matchContent = xml.getNode(match)
s = str(matchContent)
if format:
pr = prettyPrint(s)
pr = pr[pr.find("\n") + 1:]
else:
pr = s
xml.close()
return pr
def test_title():
print "test_title"
item = imsItem(mockOrg)
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
assert item.title == ""
item.load(simpleItemTestNode)
assert item.title == "Introduction"
item.title = "test"
assert item.title == "test"
xml.close()
def test_getItem():
print "test_getItem()"
xml = IceCommon.Xml(nestedItemTestXml)
nestedItemTestNode = xml.getRootNode()
item = imsItem(mockOrg, itemXmlNode=nestedItemTestNode)
childItems = item.getAllChildItems()
for childItem in childItems:
i = item.getItem(childItem.identifier)
assert i is childItem
xml.close()
assert item.getItem(item.identifier) is item
def test_resource():
print "test_resource"
item = imsItem(mockOrg)
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
item.load(simpleItemTestNode)
id = simpleItemTestNode.getAttribute("identifierref")
resource = item.resource
res = mockOrg.resources[id]
assert resource is res
xml.close()
def test_getItemByIdRef():
# NOTE: returns the first item found with this idRef
print "test_getItemByIdRef()"
xml = IceCommon.Xml(nestedItemTestXml)
nestedItemTestNode = xml.getRootNode()
item = imsItem(mockOrg, itemXmlNode=nestedItemTestNode)
childItems = item.getAllChildItems()
for childItem in childItems:
i = item.getItemByIdRef(childItem.identifierRef)
assert i is childItem
xml.close()
assert item.getItemByIdRef(item.identifierRef) is item
def test_isWordDoc():
print "test_isWordDoc"
item = imsItem(mockOrg)
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
item.load(simpleItemTestNode)
assert item.isWordDoc == False
item.resource.isWordDoc = True
assert item.isWordDoc == True
xml.close()
def read(self):
file = self.relPath
data = None
if file.endswith("/manifest.xml"):
dom = IceCommon.Xml("<dummy xmlns='http://www.imsglobal.org/xsd/imscp_v1p1'/>", \
[("x", "http://www.imsglobal.org/xsd/imscp_v1p1")])
rNode = dom.getRootNode()
resNode = dom.createElement("resource")
rNode.addChild(resNode)
for name in self.contents.keys():
fNode = dom.createElement("file", href=name)
resNode.addChild(fNode)
data = str(dom)
dom.close()
return data
def xtestImageObject(self):
fs = FileSystem(".")
fromBookFile = noMathtype
tempFs = fs.unzipToTempDirectory(fromBookFile)
xml = IceCommon.Xml(tempFs.absolutePath("content.xml"), nsList)
nodes = xml.getNodes("//draw:frame")
#nodes = xml.getNodes("//draw:frame[draw:object-ole]")
for node in nodes:
objectOleNode = node.getNode("*[local-name()='object-ole']")
self.assertFalse(objectOleNode == None,
"Only Image File not Object")
xml.close()
def setupRep(fs=None):
global repUrl
if fs is None:
fs = IceCommon.FileSystem(".")
try:
fs.delete(testSvnRep)
except: pass
try:
fs.delete(testRep)
except: pass
if IceCommon.system.isWindows:
repUrl = "file:///" + fs.join(fs.absolutePath("."), testSvnRep)
else:
repUrl = "file://" + fs.join(fs.absolutePath("."), testSvnRep)
repUrl += "/testRep"
fs.unzipToDirectory(testSvnRepZip, testSvnRep)
def test_addItemBefore():
print "test_addItemBefore()"
item1 = imsItem(mockOrg)
item1.title = "One"
item2 = imsItem(mockOrg)
item2.title = "Two"
item3 = imsItem(item2)
item3.title = "Three"
item1.addItem(item2)
item1.addItemBeforeItem(item3, item2)
xml = IceCommon.Xml("<root/>")
xml.addChild(item1.serialize(xml))
assert xml.getContent("/item/title") == "One"
assert xml.getContent("/item/item/title") == "Three"
assert xml.getContent("/item/item[2]/title") == "Two"
xml.close()
def xtestEmptyReport(self):
rep = MockRep(self.iceContext)
checker = CourseLinkCheck(self.iceContext)
report = checker.report("/")
dom = IceCommon.Xml(report)
try:
h1 = dom.getNode("//h1[1]")
h1msg = h1.getNextSibling().content
#print h1msg
self.assertEqual(h1msg, "\nNo invalid internal links\n")
h1 = dom.getNode("//h1[2]")
h1msg = h1.getNextSibling().content
#print h1msg
self.assertEqual(h1msg, "\nNo external links found\n")
finally:
dom.close()
def test_itemInit():
print "test_itemInit()"
item = imsItem(mockOrg)
xmlStr = str(item)
assert xmlStr == """<item identifierref="" identifier="" isvisible="True"><title></title></item>"""
xml = IceCommon.Xml(simpleItemTestXml)
simpleItemTestNode = xml.getRootNode()
item = imsItem(mockOrg, itemXmlNode=simpleItemTestNode)
assertSameXml(str(item), str(simpleItemTestNode))
resource = mockOrg.resources.testGetResource(0)
item = imsItem(mockOrg, resource=resource)
expected = """<item identifierref="61259e595362bef92c48bbc3a018263c" identifier="mock-61259e595362bef92c48bbc3a018263c-1" isvisible="True"><title>/test/intro/introduction.htm-title</title></item>"""
print (str(item))
assertSameXml(str(item), expected)
xml.close()
def test_load_serialize():
parent = mockParent()
ress = ImsResources(parent)
xml = IceCommon.Xml(resourcesXmlStr)
ress.load(xml.getRootNode())
href = "intro/assessment.htm"
id = "1d8994d66d3f5774b5d92b143bfd2daa"
assert ress.containsResource(href)
assert ress.getResourceByHref(href) is not None
assert ress[id] is not None
ressXmlStr = """<resources><resource href="intro/assessment.htm" identifier="1d8994d66d3f5774b5d92b143bfd2daa" mock="True"/></resources>"""
assert str(ress) == ressXmlStr
ressNode = ress.serialize(xml)
assertSameXml(ressNode, ressXmlStr)
xml.close()
def main(IceCommon, args, sys, outputWriter):
shortOptionNames = {
"h": "help",
"f": "file",
"d": "directory",
"dir": "directory",
"converter": "convert",
"v": "verbose",
"test": "testing"
}
flags = [
"help", "convert", "atompub", "atomconvertpub", "upgrade", "verbose",
"asserviceonly", "enableexternalaccess", "test"
]
progName = args.pop(0)
options = IceCommon.getOptions(args, shortOptionNames, flags)
iceWebServer(IceCommon, options, outputWriter)
outputWriter("\n")
return 0
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
from ice_common import IceCommon
IceCommon.setup()
from xml_diff import XmlTestCase, XmlDiff
from ims_resources import ImsResources
imsNSList = [ \
("ims", "http://www.imsglobal.org/xsd/imscp_v1p1"), \
("imsmd", "http://www.imsglobal.org/xsd/imsmd_v1p2"), \
("xsi", "http://www.w3.org/2001/XMLSchema-instance"), \
]
resourcesXmlStr = """<resources>
<resource identifier="1d8994d66d3f5774b5d92b143bfd2daa" type="webcontent"
def main(args, sys, outputWriter):
shortOptionNames = {"h":"help", "f":"file", "d":"directory", "dir":"directory",
"converter":"convert", "v":"verbose", "test":"testing"}
flags = ["help", "convert", "atompub", "atomconvertpub", "upgrade",
"verbose", "asserviceonly", "enableexternalaccess", "test", "open"]
progName = args.pop(0)
options = IceCommon.getOptions(args, shortOptionNames, flags)
fs = IceCommon.FileSystem(IceCommon.workingDirectory)
convert = options.get("convert", False)
atompub = options.get("atompub", False) or options.get("atomconvertpub", False)
if convert or atompub:
file = options.get("file")
directory = options.get("directory")
template = options.get("template")
if file is not None:
options["file"] = fs.absolutePath(file)
if directory is not None:
options["directory"] = fs.absolutePath(directory)
if template is not None:
options["template"] = fs.absolutePath(template)
class OurOutput(object):
def __init__(self):
import tempfile
self.__f = open(tempfile.gettempdir() + "/ice.log", "wb")
def write(self, data):
sys.stdout.write(data)
self.__f.write(data.replace("\n", "\r\n"))
def close(self):
self.__f.close()
output = OurOutput()
stderr = sys.stderr
sys.stderr = output
converterAppMain(progName, options, fs=fs, output=output)
output.close()
sys.stderr = stderr
elif options.get("svn", None) is not None:
# SVN command
usageMessage = "Usage: -svn:export -path:UrlOrAbsolutePathToExport -dir:exportToDirectory"
svnCommand = options.get("svn").lower()
if options.get("help") is not None:
outputWriter("%s\n" % usageMessage)
return(1)
if svnCommand=="export":
# from 'path' to 'dir'
path = options.get("path")
toDir = options.get("directory")
if path is None or toDir is None:
outputWriter("%s\n" % usageMessage)
else:
try:
outputWriter("Exporting '%s' to '%s'. Please wait...\n" % (path, toDir))
import pysvn
client = pysvn.Client()
#path = fs.absolutePath(path)
#toDir = fs.absolutePath(toDir)
result = client.export(path, toDir, force=True, revision=pysvn.Revision(pysvn.opt_revision_kind.head), recurse=True)
outputWriter("Exported: %s\n" % str(result))
outputWriter("Export completed.\n")
except Exception, e:
outputWriter("Error exporting: %s\n" % str(e))
else:
outputWriter("%s\n" % usageMessage)
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
try:
from ice_common import IceCommon
IceCommon.setup()
except:
import sys, os
sys.path.append(".")
os.chdir("../../")
from ice_common import IceCommon
# XmlTestCase # self.assertSameXml
from plugin_tags import *
class MockProperty(object):
def __init__(self):
self.guid = 1234
self.relPath = "relPath/"
def setUp(self):
# change the logger printHandler so that it does not print
try:
for handler in logger.handlers:
if handler.__class__.__name__=="printHandler":
def emit(record):
#print handler.format(record)
pass
handler.emit = emit
except:
pass
self.output = StringIO()
iceRender = IceRender(IceCommon)
if False: # use mock objects
self.basePath = "/root/"
self.svnUrl = "http://testingSvnUrl/"
self.history = []
self.files = {"/root/.site/site.py":("#data", None)}
self.mockFs = MockFileSystem(self.files)
self.mockSvnRep = MockSvnRep(basePath=self.basePath, svnUrl=self.svnUrl, \
files=self.files, history=self.history)
self.iceRep = IceRepository(basePath=self.basePath, repUrl=self.svnUrl, \
name="Default", svnRep=self.mockSvnRep, fileSystem=self.mockFs, \
output=self.output, iceRender=iceRender)
self.iceRep.setExecDataMethod(self.dummyMethod)
else:
removeTempFSRep()
createTempFSRep()
self.svnUrl = tempFSRepUrl
self.basePath = tempRepPath
basePath = fs.absolutePath(self.basePath)
iceContext = IceCommon()
iceContext.output = self.output
# use the dummy indexer for testing
iceContext.RepositoryIndexer = iceContext.DummyRepositoryIndexer
svnRep = IceCommon.SvnRep(iceContext, basePath=basePath, svnUrl=self.svnUrl, \
iceLogger=None, output=None)
self.iceRep = IceRepository(iceContext, basePath=self.basePath, repUrl=self.svnUrl, \
name="Default", svnRep=svnRep, fileSystem=fs, output=self.output, \
iceRender=MockIceRender(iceContext))
#iceRender=iceRender)
#print "---"
#print iceRender.getRenderableFrom(".odt")
#print iceRender.getRenderableTypes(".odt")
#print iceRender.getRenderableExtensions()
#print "---"
self.iceRep2 = None
#
#global fs
#fs = FileSystem(".")
#
def wrappedReadFile(path):
#print "readFile('%s')" % path
if path.endswith("/.site/site.py"):
return "#"
return readFile(path)
if fs.readFile!=wrappedReadFile:
readFile = fs.readFile
fs.readFile = wrappedReadFile
#
def wrappedIsFile(path):
#print "isFile('%s')" % path
if path.endswith("/.site/site.py"):
return True
r = isFile(path)
return r
if fs.isFile!=wrappedIsFile:
isFile = fs.isFile
fs.isFile = wrappedIsFile
self.xmlContent = "<body>This is some testdata.</body>"
self.title = "Title"
