def _getPath(self, path=None):
if path is None:
path = Path()
path.set('//')
return path
def testImportWithCopy(self):
def mkdir(parent, name, child):
if child is not None:
return child
return Item(name, parent, None)
cineguidePack = os.path.join(self.testdir, 'data', 'packs',
'cineguide.pack')
view = self.rep.view
nv.loadPack(self.chandlerPack)
nv.loadPack(cineguidePack)
nv.findPath('//CineGuide/KHepburn').movies.addIndex('n', 'numeric')
nv.findPath('//CineGuide/KHepburn').movies.addIndex('t', 'attribute',
attribute='title')
self._setCopyExport(nv['Schema'])
self._unsetCopyExport(nv['Schema']['Core']['items'])
view.walk(Path('//Schema/CineGuide/Kinds'), mkdir)
view.walk(Path('//Schema/CineGuide/Attributes'), mkdir)
view.walk(Path('//Schema/CineGuide/Types'), mkdir)
view.commit()
view.importItem(nv.findPath('//CineGuide/KHepburn'))
self.assert_(view.check())
self.assert_(nv.check())
view.commit()
self._reopenRepository()
self.assert_(self.rep.view.check())
def _getPath(self, path=None):
if path is None:
path = Path()
path.set('//')
return path
def testTask(self):
""" Simple test for creating instances of tasks """
def _verifyTask(task):
self.assert_(task != None)
self.assertEqual(task.displayName, "test headline")
self.assertEqual(task.getItemDisplayName(), "test headline")
self.assertEqual(task.importance, 'important')
self.assertEqual(task.getAttributeValue('importance'), 'important')
self.assertEqual(task.about, "test headline")
self.loadParcel("parcel:osaf.pim.tasks")
# Check that the globals got created by the parcel
view = self.rep.view
taskPath = Path('//parcels/osaf/pim/tasks')
self.assert_(Task.getKind(view) != None)
self.assert_(view.find(Path(taskPath, 'Task')) != None)
self.assertEqual(Task.getKind(view), view.find(Path(taskPath, 'Task')))
# Construct A Sample Item
taskItem = Task("TestTask", view=view)
taskItem.displayName = "test headline"
taskItem.importance = "important"
self._reopenRepository()
view = self.rep.view
contentItemParent = view.findPath("//userdata")
taskItem2 = contentItemParent.getItemChild("TestTask")
_verifyTask(taskItem2)
def dir(self, item=None, path=None):
"""
Print out a listing of each item in the repository or under item.
This is a debugging feature.
@param item: the item to list children of, or C{None}
@type item: an item
@param path: the path to the item to list children of, or C{None}
@type path: a L{Path<repository.util.Path.Path>} instance
"""
if item is None:
path = Path('//')
for root in self.iterRoots():
self.dir(root, path)
else:
if path is None:
path = item.itsPath
else:
path.append(item._name or item._uuid)
print path
for child in item.iterChildren():
self.dir(child, path)
path.pop()
def getTypeName(self, attribute, attrs, default):
name = None
if attrs.has_key('typeid'):
try:
name = self.repository[UUID(attrs['typeid'])].handlerName()
except KeyError:
raise TypeError, "Type %s not found" % (attrs['typeid'])
elif attrs.has_key('typepath'):
typeItem = self.repository.find(Path(attrs['typepath']))
if typeItem is None:
raise TypeError, "Type %s not found" % (attrs['typepath'])
name = typeItem.handlerName()
elif attrs.has_key('type'):
name = attrs['type']
elif attribute is not None:
attrType = attribute.getAspect('type', None)
if attrType is not None:
name = attrType.handlerName()
return name or default
def _makeValidValues(self):
""" create valid values of appropriate types"""
class myStruct(object):
__slots__ = ('name', 'rank')
self.uuid = self.attrKind.itsUUID
self.uuidString = str(self.uuid)
self.pathString = '//Schema/Core/Item'
self.path = Path(self.pathString)
self.singleRef = SingleRef(self.uuid)
self.itemClass = eval('repository.item.Item.Item')
self.dateTimeString = '2004-01-08 12:34:56 US/Mountain'
self.dateTime = datetime(2004, 1, 8, 12, 34, 56,
tzinfo=ICUtzinfo.getInstance('US/Mountain'))
self.timeDeltaString= '-8+45.000012'
self.timeDelta = timedelta(-8, 45, 12)
self.enum = self.types['Enumeration'].newItem('myEnum', self.rep)
self.enum.values = ['red', 'green', 'blue']
self.structType = self.types['Struct'].newItem('myStruct', self.rep)
self.structType.fields=['name','rank']
self.structType.implementationTypes = {'python': myStruct }
self.struct = myStruct()
self.lob = self.types['Lob'].makeValue("aba;dsjfa;jfdl;ajru87z.vncxyt89q47654", encoding='utf-8', mimetype='text/plain')
def itemStart(self, attrs):
parent = None
if attrs.get('afterLoadHooks', 'False') == 'True':
self.hooks.append([])
if attrs.has_key('path'):
parent = self.view.find(Path(attrs['path']))
elif attrs.has_key('uuid'):
parent = self.view.find(UUID(attrs['uuid']))
elif attrs.has_key('file'):
parent = self.loadItem(os.path.join(self.cwd[-1], attrs['file']),
self.parent[-1])
elif attrs.has_key('files'):
pattern = '^' + attrs['files'] + '$'
pattern = pattern.replace('.', '\\.').replace('*', '.*')
exp = re.compile(pattern)
for file in os.listdir(self.cwd[-1]):
if exp.match(file):
parent = self.loadItem(os.path.join(self.cwd[-1], file),
self.parent[-1])
if self.errorOccurred():
return
self.parent.append(parent)
if attrs.has_key('cwd'):
self.cwd.append(os.path.join(self.cwd[-1], attrs['cwd']))
def testWalk(self):
def callme(self, path, x):
print path
print x.itsName
self.rep.walk(Path('//Schema/Core/Parcel'), callme)
#TODO what's a resonable test here?
pass
def kindEnd(self, itemHandler, attrs):
if attrs['type'] == 'uuid':
self.kindRef = UUID(self.data)
else:
self.kindRef = Path(self.data)
self.kind = self.repository._findSchema(self.kindRef, self.withSchema)
def __getFeeds(self):
"""Return a list of channel items"""
repository = self.rep
chanKind = repository.find(Path(BASE_PATH, 'RSSChannel'))
feeds = []
parent = repository.find(BASE_PATH)
for url in _defaultBlogs:
urlhash = str(hash(url))
item = repository.find(Path(BASE_PATH, urlhash))
if not item:
item = zaobao.RSSChannel(view=repository.view)
item.url = url
feeds.append(item.itsUUID)
return feeds
def testNotes(self):
""" Simple test for creating instances of note related kinds """
self.loadParcel("parcel:osaf.pim")
def _verifyNote(note):
self.assertEqual(note.displayName, "sample note")
reader = note.body.getReader()
self.assertEqual(reader.read(), "more elaborate sample note body")
reader.close()
# Test the globals
notesPath = Path('//parcels/osaf/pim')
view = self.rep.view
self.assertEqual(pim.Note.getKind(view),
view.find(Path(notesPath, 'Note')))
# Construct sample items
noteItem = pim.Note("noteItem", view=view)
# Double check kinds
self.assertEqual(noteItem.itsKind, pim.Note.getKind(view))
# Literal properties
noteItem.displayName = "sample note"
# Lob property
lobType = noteItem.getAttributeAspect('body', 'type')
# when data is unicode, encoding defaults to utf-8
noteItem.body = lobType.makeValue(u"more elaborate sample note body")
_verifyNote(noteItem)
self._reopenRepository()
contentItemParent = self.rep.findPath("//userdata")
noteItem = contentItemParent.getItemChild("noteItem")
_verifyNote(noteItem)
def setUp(self):
super(TestIndexes, self).setUp()
cineguidePack = os.path.join(self.testdir, 'data', 'packs',
'cineguide.pack')
self.kh = Path('//CineGuide/KHepburn')
self.rep.loadPack(cineguidePack)
self.rep.find(self.kh).movies.addIndex('n', 'numeric')
self.rep.commit()
def parentEnd(self, itemHandler, attrs):
if attrs['type'] == 'uuid':
self.parentRef = UUID(self.data)
else:
self.parentRef = Path(self.data)
self.isContainer = attrs.get('container', 'False') == 'True'
self.parent = self.repository.find(self.parentRef)
if self.parent is None:
self.afterLoadHooks.append(self._move)
def dir(self, item=None, path=None):
"""
Print out a listing of each item in the repository or under item.
This is a debugging feature.
@param item: the item to list children of, or C{None}
@type item: an item
@param path: the path to the item to list children of, or C{None}
@type path: a L{Path<repository.util.Path.Path>} instance
"""
if item is None:
path = Path('//')
for root in self.iterRoots():
self.dir(root, path)
else:
if path is None:
path = item.itsPath
else:
path.append(item._name or item._uuid)
print path
for child in item.iterChildren():
self.dir(child, path)
path.pop()
def testContacts(self):
""" Simple test for creating instances of contact related kinds """
self.loadParcel("parcel:osaf.pim.contacts")
def _verifyContactName(name):
self.assertEqual(name.firstName, 'Sylvia')
self.assertEqual(name.getAttributeValue('firstName'), 'Sylvia')
self.assertEqual(name.lastName, 'Plath')
self.assertEqual(name.getAttributeValue('lastName'), 'Plath')
# Test the globals
contactsPath = Path('//parcels/osaf/pim/contacts')
view = self.rep.view
self.assertEqual(Contact.getKind(view),
view.find(Path(contactsPath, 'Contact')))
self.assertEqual(ContactName.getKind(view),
view.find(Path(contactsPath, 'ContactName')))
# Construct sample items
contactItem = Contact("contactItem", view=view)
contactNameItem = ContactName("contactNameItem", view=view)
# Double check kinds
self.assertEqual(contactItem.itsKind, Contact.getKind(view))
self.assertEqual(contactNameItem.itsKind, ContactName.getKind(view))
# Literal properties
contactNameItem.firstName = "Sylvia"
contactNameItem.lastName = "Plath"
_verifyContactName(contactNameItem)
self._reopenRepository()
contentItemParent = self.rep.findPath("//userdata")
contactNameItem = contentItemParent.getItemChild("contactNameItem")
_verifyContactName(contactNameItem)
def _find(spec):
typeAttr = attrs.get('type', 'path')
if typeAttr == 'path':
item = self.parent.find(Path(spec))
elif typeAttr == 'uuid':
item = self.parent.find(UUID(spec))
else:
raise TypeError, typeAttr
if item is None:
raise NoSuchItemError, (spec, self.version)
return item
def refEnd(self, itemHandler, attrs):
if self.tags[-1] == 'item':
attribute = self.attributes.pop()
cardinality = self.getCardinality(attribute, attrs)
otherCard = attrs.get('otherCard', None)
else:
cardinality = 'single'
otherCard = self.tagAttrs[-1].get('otherCard', None)
if cardinality == 'single': # cardinality of tag
typeName = attrs.get('type', 'path')
if typeName == 'path':
ref = Path(self.data)
elif typeName == 'none':
self.references[attrs['name']] = None
return
else:
ref = UUID(self.data)
if self.collections:
refList = self.collections[-1]
self.refs.append(
RefArgs(refList._name,
None,
refList._otherName,
ref,
otherCard=otherCard,
otherAlias=attrs.get('otherAlias'),
previous=self.refName(attrs, 'previous'),
next=self.refName(attrs, 'next'),
alias=attrs.get('alias')))
else:
name = attrs['name']
otherName = self.getOtherName(name, self.getAttribute(name),
attrs)
self.refs.append(
RefArgs(name,
None,
otherName,
ref,
otherCard=otherCard,
otherAlias=attrs.get('otherAlias')))
else:
value = self.collections.pop()
self.references[attrs['name']] = value
if value._indexes:
self.afterLoadHooks.append(value._restoreIndexes)
def testLocations(self):
""" Simple test for the Locations Factory - getLocation """
self.loadParcel("parcel:osaf.pim.calendar")
# Test the globals
locationsPath = Path('//parcels/osaf/pim/calendar')
view = self.rep.view
self.assertEqual(Calendar.Location.getKind(view),
view.find(Path(locationsPath, 'Location')))
locationNames = ["Alderon", "Atlantis", "Arcadia"]
# Construct sample items
for loc in locationNames:
# use the factory to create or lookup an item
aRoom = Calendar.Location.getLocation(view, loc)
# test that convert to string yeilds the name of the location
self.assertEqual(loc, str(aRoom))
# call the factory on the last name again, to ensure reuse
sameLocation = Calendar.Location.getLocation(view, locationNames[-1])
self.assert_(aRoom is sameLocation,
"Location factory failed to return the same location!")
# Double check kinds
self.assertEqual(aRoom.itsKind, Calendar.Location.getKind(view))
# Literal properties
aRoom.displayName = "A Nice Place" # change the Location name
# make sure we can get the name, and find it by that name
sameLocation = Calendar.Location.getLocation(view, aRoom.displayName)
self.assert_(
aRoom is sameLocation,
"Location factory failed to return an identical location!")
def findPath(self, path, load=True):
"""
Find an item by path.
See L{find} for more information.
@param path: a path
@type path: L{Path<repository.util.Path.Path>} or a path string
@param load: load the item if it not yet loaded, C{True} by default
@type load: boolean
@return: an item or C{None} if not found
"""
if isinstance(path, str) or isinstance(path, unicode):
path = Path(path)
elif not isinstance(path, Path):
raise TypeError, '%s is not Path or string' % (type(path))
return self._fwalk(path, load)
def packStart(self, attrs):
if attrs.has_key('cwd'):
self.cwd[-1] = os.path.join(self.cwd[-1], attrs['cwd'])
if attrs.has_key('file'):
if not self.view.find(Path('//', 'Packs', attrs['name'])):
try:
self.view.loadPack(
os.path.join(self.cwd[-1], attrs['file']),
self.parent[-1])
except:
self.saveException()
return
else:
self.name = attrs['name']
self.pack = Item(self.name, self.packs, None)
self.hooks.append([])
def testMail(self):
""" Simple test for creating instances of email related kinds """
self.loadParcel("parcel:osaf.pim.mail")
# Test the globals
mailPath = Path('//parcels/osaf/pim/mail')
view = self.rep.view
self.assertEqual(Mail.AccountBase.getKind(view),
view.find(Path(mailPath, 'AccountBase')))
self.assertEqual(Mail.IMAPAccount.getKind(view),
view.find(Path(mailPath, 'IMAPAccount')))
self.assertEqual(Mail.SMTPAccount.getKind(view),
view.find(Path(mailPath, 'SMTPAccount')))
self.assertEqual(Mail.MailDeliveryError.getKind(view),
view.find(Path(mailPath, 'MailDeliveryError')))
self.assertEqual(Mail.MailDeliveryBase.getKind(view),
view.find(Path(mailPath, 'MailDeliveryBase')))
self.assertEqual(Mail.SMTPDelivery.getKind(view),
view.find(Path(mailPath, 'SMTPDelivery')))
self.assertEqual(Mail.IMAPDelivery.getKind(view),
view.find(Path(mailPath, 'IMAPDelivery')))
self.assertEqual(Mail.MIMEBase.getKind(view),
view.find(Path(mailPath, 'MIMEBase')))
self.assertEqual(Mail.MIMENote.getKind(view),
view.find(Path(mailPath, 'MIMENote')))
self.assertEqual(Mail.MailMessage.getKind(view),
view.find(Path(mailPath, 'MailMessage')))
self.assertEqual(Mail.MailMessageMixin.getKind(view),
view.find(Path(mailPath, 'MailMessageMixin')))
self.assertEqual(Mail.MIMEBinary.getKind(view),
view.find(Path(mailPath, 'MIMEBinary')))
self.assertEqual(Mail.MIMEText.getKind(view),
view.find(Path(mailPath, 'MIMEText')))
self.assertEqual(Mail.MIMEContainer.getKind(view),
view.find(Path(mailPath, 'MIMEContainer')))
self.assertEqual(Mail.MIMESecurity.getKind(view),
view.find(Path(mailPath, 'MIMESecurity')))
self.assertEqual(Mail.EmailAddress.getKind(view),
view.find(Path(mailPath, 'EmailAddress')))
# Construct sample items
accountBaseItem = Mail.AccountBase("accountBaseItem", view=view)
imapAccountItem = Mail.IMAPAccount("imapAccountItem", view=view)
smtpAccountItem = Mail.SMTPAccount("smtpAccountItem", view=view)
mailDeliveryErrorItem = Mail.MailDeliveryError("mailDeliveryErrorItem",
view=view)
mailDeliveryBaseItem = Mail.MailDeliveryBase("mailDeliveryBaseItem",
view=view)
smtpDeliveryItem = Mail.SMTPDelivery("smtpDeliveryItem", view=view)
imapDeliveryItem = Mail.IMAPDelivery("imapDeliveryItem", view=view)
mimeBaseItem = Mail.MIMEBase("mimeBaseItem", view=view)
mimeNoteItem = Mail.MIMENote("mimeNoteItem", view=view)
mailMessageItem = Mail.MailMessage("mailMessageItem", view=view)
mailMessageMixinItem = Mail.MailMessageMixin("mailMessageMixinItem",
view=view)
mimeBinaryItem = Mail.MIMEBinary("mimeBinaryItem", view=view)
mimeTextItem = Mail.MIMEText("mimeTextItem", view=view)
mimeContainerItem = Mail.MIMEContainer("mimeContainerItem", view=view)
mimeSecurityItem = Mail.MIMESecurity("mimeSecurityItem", view=view)
emailAddressItem = Mail.EmailAddress("emailAddressItem", view=view)
# Double check kinds
self.assertEqual(accountBaseItem.itsKind,
Mail.AccountBase.getKind(view))
self.assertEqual(imapAccountItem.itsKind,
Mail.IMAPAccount.getKind(view))
self.assertEqual(smtpAccountItem.itsKind,
Mail.SMTPAccount.getKind(view))
self.assertEqual(mailDeliveryErrorItem.itsKind,
Mail.MailDeliveryError.getKind(view))
self.assertEqual(mailDeliveryBaseItem.itsKind,
Mail.MailDeliveryBase.getKind(view))
self.assertEqual(smtpDeliveryItem.itsKind,
Mail.SMTPDelivery.getKind(view))
self.assertEqual(imapDeliveryItem.itsKind,
Mail.IMAPDelivery.getKind(view))
self.assertEqual(mimeBaseItem.itsKind, Mail.MIMEBase.getKind(view))
self.assertEqual(mimeNoteItem.itsKind, Mail.MIMENote.getKind(view))
self.assertEqual(mailMessageItem.itsKind,
Mail.MailMessage.getKind(view))
self.assertEqual(mailMessageMixinItem.itsKind,
Mail.MailMessageMixin.getKind(view))
self.assertEqual(mimeBinaryItem.itsKind, Mail.MIMEBinary.getKind(view))
self.assertEqual(mimeTextItem.itsKind, Mail.MIMEText.getKind(view))
self.assertEqual(mimeContainerItem.itsKind,
Mail.MIMEContainer.getKind(view))
self.assertEqual(mimeSecurityItem.itsKind,
Mail.MIMESecurity.getKind(view))
self.assertEqual(emailAddressItem.itsKind,
Mail.EmailAddress.getKind(view))
accountBaseItem = self.__populateAccount(accountBaseItem)
smtpAccountItem = self.__populateAccount(smtpAccountItem)
imapAccountItem = self.__populateAccount(imapAccountItem)
mailDeliveryErrorItem.errorCode = 25
mailDeliveryErrorItem.errorString = "Test String"
mailDeliveryErrorItem.errorDate = datetime.now()
smtpDeliveryItem.state = "DRAFT"
smtpDeliveryItem.deliveryError = mailDeliveryErrorItem
imapDeliveryItem.uid = 0
mimeBaseItem.mimeType = "SGML"
mimeBinaryItem.mimeType = "APPLICATION"
mimeTextItem.mimeType = "PLAIN"
mimeContainerItem.mimeType = "ALTERNATIVE"
mimeSecurityItem.mimeType = "SIGNED"
# Literal properties
mailMessageItem.dateSent = datetime.now()
mailMessageItem.dateReceived = datetime.now()
mailMessageItem.subject = "Hello"
mailMessageItem.spamScore = 5
# Item Properties
emailAddressItem.emailAddress = "*****@*****.**"
mailMessageItem.replyAddress = emailAddressItem
self._reopenRepository()
view = self.rep.view
contentItemParent = view.findPath("//userdata")
mailMessageItem = contentItemParent.getItemChild("mailMessageItem")
#Test cloud membership
items = mailMessageItem.getItemCloud('copying')
self.assertEqual(len(items), 1)
class TestMerge(RepositoryTestCase):
""" Test item merging """
itemPath = Path('//Schema/Core/Item')
kindPath = Path('//Schema/Core/Kind')
attributePath = Path('//Schema/Core/Attribute')
cPath = Path('//kinds/c')
def setUp(self):
super(TestMerge, self).setUp()
item = self.rep.find(TestMerge.itemPath)
kind = self.rep.find(TestMerge.kindPath)
attribute = self.rep.find(TestMerge.attributePath)
kinds = item.newItem('kinds', self.rep)
item.newItem('cm', self.rep)
item.newItem('co', self.rep)
p = kind.newItem('p', kinds)
p.addValue('superKinds', item)
c = kind.newItem('c', kinds)
c.addValue('superKinds', item)
ap = attribute.newItem('ap', p)
ap.otherName = 'ac'
ap.cardinality = 'list'
p.addValue('attributes', ap, alias='ap')
ac = attribute.newItem('ac', c)
ac.otherName = 'ap'
ac.cardinality = 'single'
c.addValue('attributes', ac, alias='ac')
p.newItem('p', self.rep)
self.rep.commit()
def merge(self, o, m):
pm = self.rep['p']
km = self.rep.find(TestMerge.cPath)
am = []
oc = [c.itsName for c in pm.iterChildren()]
view = self.rep.createView('view')
main = self.rep.setCurrentView(view)
po = self.rep['p']
ko = self.rep.find(TestMerge.cPath)
ao = []
for i in xrange(o):
ao.append(ko.newItem('ao_%02d' %(i), po))
view.commit()
view = self.rep.setCurrentView(main)
for i in xrange(m):
am.append(km.newItem('am_%02d' %(i), pm))
main.commit()
ic = [c.itsName for c in pm.iterChildren()]
uc = oc[:]
uc.extend([c.itsName for c in ao])
uc.extend([c.itsName for c in am])
self.assert_(ic == uc)
c = pm._children
for i in xrange(o - 1):
self.assert_(c.nextKey(ao[i].itsUUID) == ao[i + 1].itsUUID)
for i in xrange(1, o):
self.assert_(c.previousKey(ao[i].itsUUID) == ao[i - 1].itsUUID)
self.assert_(c.nextKey(ao[o - 1].itsUUID) == am[0].itsUUID)
self.assert_(c.previousKey(am[0].itsUUID) == ao[o - 1].itsUUID)
for i in xrange(m - 1):
self.assert_(c.nextKey(am[i].itsUUID) == am[i + 1].itsUUID)
for i in xrange(1, m):
self.assert_(c.previousKey(am[i].itsUUID) == am[i - 1].itsUUID)
self.assert_(c.lastKey() == am[m - 1].itsUUID)
def mergeRefs(self, o, m):
pm = self.rep['p']
cm = self.rep['cm']
km = self.rep.find(TestMerge.cPath)
am = []
oc = [c.itsName for c in pm.ap]
view = self.rep.createView('view')
main = self.rep.setCurrentView(view)
po = self.rep['p']
co = self.rep['co']
ko = self.rep.find(TestMerge.cPath)
ao = []
for i in xrange(o):
c = ko.newItem('ao_%02d' %(i), co)
c.ac = po
#po.ap.dir()
ao.append(c)
view.commit()
view = self.rep.setCurrentView(main)
for i in xrange(m):
c = km.newItem('am_%02d' %(i), cm)
c.ac = pm
#pm.ap.dir()
am.append(c)
main.commit()
ic = [c.itsName for c in pm.ap]
uc = oc[:]
uc.extend([c.itsName for c in ao])
uc.extend([c.itsName for c in am])
self.assert_(ic == uc)
c = pm.ap
for i in xrange(o - 1):
self.assert_(c.nextKey(ao[i].itsUUID) == ao[i + 1].itsUUID)
for i in xrange(1, o):
self.assert_(c.previousKey(ao[i].itsUUID) == ao[i - 1].itsUUID)
self.assert_(c.nextKey(ao[o - 1].itsUUID) == am[0].itsUUID)
self.assert_(c.previousKey(am[0].itsUUID) == ao[o - 1].itsUUID)
for i in xrange(m - 1):
self.assert_(c.nextKey(am[i].itsUUID) == am[i + 1].itsUUID)
for i in xrange(1, m):
self.assert_(c.previousKey(am[i].itsUUID) == am[i - 1].itsUUID)
self.assert_(c.lastKey() == am[m - 1].itsUUID)
def rename(self, o_name, m_name):
pm = self.rep['p']
km = self.rep.find(TestMerge.cPath)
cm = km.newItem('child', pm)
self.rep.commit()
view = self.rep.createView('view')
main = self.rep.setCurrentView(view)
po = self.rep['p']
co = po['child']
co.rename(o_name)
view.commit()
view = self.rep.setCurrentView(main)
cm.rename(m_name)
main.commit()
def move(self, o_name, m_name):
pm = self.rep['p']
km = self.rep.find(TestMerge.cPath)
cm = km.newItem('child', pm)
km.newItem(m_name, self.rep)
if o_name != m_name:
km.newItem(o_name, self.rep)
self.rep.commit()
view = self.rep.createView('view')
main = self.rep.setCurrentView(view)
po = self.rep['p']
co = po['child']
co.move(self.rep[o_name])
view.commit()
view = self.rep.setCurrentView(main)
cm.move(self.rep[m_name])
main.commit()
def test1Merge1(self):
self.rep.find(TestMerge.cPath).newItem('c0', self.rep['p'])
self.rep.commit()
self.merge(1, 1)
def test1Merge2(self):
self.rep.find(TestMerge.cPath).newItem('c0', self.rep['p'])
self.rep.commit()
self.merge(2, 2)
def test1MergeN(self):
self.rep.find(TestMerge.cPath).newItem('c0', self.rep['p'])
self.rep.commit()
self.merge(5, 8)
self.assert_(self.rep.view.check(), 'view did not check out')
def test0Merge1(self):
self.merge(1, 1)
def test0Merge2(self):
self.merge(2, 2)
def test0MergeN(self):
self.merge(6, 9)
def testRenameSameSame(self):
self.rename('foo', 'foo')
def testRenameSameDifferent(self):
try:
self.rename('foo', 'bar')
except MergeError, e:
#print e
self.assert_(e.getReasonCode() == MergeError.RENAME)
def testCalendar(self):
""" Simple test for creating instances of calendar related kinds """
self.loadParcel("parcel:osaf.pim.calendar")
def _verifyCalendarEvent(event):
self.assertEqual(event.displayName, "simple headline")
self.assertEqual(event.getItemDisplayName(), "simple headline")
self.assertEqual(event.importance, 'fyi')
self.assertEqual(event.getAttributeValue('importance'), 'fyi')
self.assertEqual(event.transparency, "confirmed")
self.assertEqual(event.getAttributeValue('transparency'), "confirmed")
self.assertEqual(event.allDay, False)
self.assertEqual(event.getAttributeValue('allDay'), False)
self.assertEqual(event.anyTime, True)
self.assertEqual(event.getAttributeValue('anyTime'), True)
def _verifyCalendarItems(calendar, location, recurrence):
self.assertEqual(calendar.displayName, "simple calendar")
self.assertEqual(calendar.getAttributeValue('displayName'),
"simple calendar")
self.assertEqual(location.displayName, "simple location")
self.assertEqual(location.getAttributeValue('displayName'),
"simple location")
# Check that the globals got created by the parcel
calendarPath = Path('//parcels/osaf/pim/calendar')
view = self.rep.view
self.assertEqual(Calendar.CalendarEvent.getKind(view),
view.find(Path(calendarPath, 'CalendarEvent')))
self.assertEqual(Calendar.Calendar.getKind(view),
view.find(Path(calendarPath, 'Calendar')))
self.assertEqual(Calendar.Location.getKind(view),
view.find(Path(calendarPath, 'Location')))
self.assertEqual(Calendar.RecurrencePattern.getKind(view),
view.find(Path(calendarPath, 'RecurrencePattern')))
# Construct a sample item
calendarEventItem = Calendar.CalendarEvent("calendarEventItem",
view=view)
calendarItem = Calendar.Calendar("calendarItem", view=view)
locationItem = Calendar.Location("locationItem", view=view)
recurrenceItem = Calendar.RecurrencePattern("recurrenceItem", view=view)
# CalendarEvent properties
calendarEventItem.displayName = "simple headline"
calendarEventItem.importance = "fyi"
_verifyCalendarEvent(calendarEventItem)
calendarEventItem.location = locationItem
# Calendar properties
calendarItem.displayName = "simple calendar"
locationItem.displayName = "simple location"
_verifyCalendarItems(calendarItem, locationItem,
recurrenceItem)
# Check cloud membership - event + location
items = calendarEventItem.getItemCloud('copying')
self.assertEqual(len(items), 2)
# Re-examine items
self._reopenRepository()
contentItemParent = self.rep.findPath("//userdata")
calendarEventItem = contentItemParent.getItemChild("calendarEventItem")
calendarItem = contentItemParent.getItemChild("calendarItem")
locationItem = contentItemParent.getItemChild("locationItem")
recurrenceItem = contentItemParent.getItemChild("recurrenceItem")
_verifyCalendarEvent(calendarEventItem)
_verifyCalendarItems(calendarItem, locationItem,
recurrenceItem)
os.path.join(_chandlerDir, 'parcels', 'osaf', 'examples', 'zaobao'))
import feedparser
# get all the RSS files in RSS_HOME (repository/tests/data/rssfeeds)
# You can obtain the files from http://aloha.osafoundation.org/~twl/RSSdata/rssfeeds.syndic8.tar.bz2
RSS_HOME = os.path.join(_chandlerDir, 'repository', 'tests', 'data',
'rssfeeds/')
if os.path.exists(RSS_HOME):
_rssfiles = os.listdir(RSS_HOME)
else:
_rssfiles = []
# make them file URL's
_defaultBlogs = ["%s%s%s" % ("", RSS_HOME, f) for f in _rssfiles]
BASE_PATH = Path('//parcels/osaf/examples/zaobao/schema')
class TestPerfWithRSS(RepositoryTestCase):
""" Simple performance tests """
def setUp(self):
super(TestPerfWithRSS, self).setUp()
# sys.path.insert(1, parcelDir)
self.loadParcel("parcel:osaf.examples.zaobao")
self.rep.commit()
self.rep.logger.debug("Going to try: ", len(_defaultBlogs), " feeds")
def _stressTest(self, commitInsideLoop=False):
class RepositoryTestCase(TestCase):
logLevel = logging.WARNING # a nice quiet default
def _setup(self, ramdb=True):
schema.reset()
self.rootdir = os.environ['CHANDLERHOME']
self.chandlerPack = os.path.join(self.rootdir, 'repository', 'packs',
'chandler.pack')
handler = \
logging.FileHandler(os.path.join(self.rootdir,'chandler.log'))
formatter = \
logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
handler.setFormatter(formatter)
root = logging.getLogger()
root.addHandler(handler)
self.ramdb = ramdb
def _openRepository(self, ramdb=True):
preloadedRepositoryPath = os.path.join(self.testdir,
'__preloaded_repository__')
self.rep = DBRepository(os.path.join(self.testdir, '__repository__'))
if os.path.exists(preloadedRepositoryPath):
self.ramdb = False
self.rep.open(ramdb=False,
restore=preloadedRepositoryPath,
refcounted=True)
self.rep.logger.setLevel(self.logLevel)
self.rep.logger.info('Using preloaded repository')
else:
self.rep.create(ramdb=self.ramdb, refcounted=True)
self.rep.logger.setLevel(self.logLevel)
self.rep.loadPack(self.chandlerPack)
self.rep.commit()
self.manager = \
ParcelManager.get(self.rep.view, \
path=[os.path.join(self.rootdir, 'parcels')])
def setUp(self, ramdb=True):
self._setup(ramdb)
self.testdir = os.path.join(self.rootdir, 'repository', 'tests')
self._openRepository(ramdb)
def tearDown(self):
self.rep.close()
self.rep.logger.debug('RAMDB = %s', self.ramdb)
if not self.ramdb:
self.rep.delete()
def _reopenRepository(self):
self.rep.commit()
if self.ramdb:
self.rep.closeView()
self.rep.openView()
else:
self.rep.close()
self.rep = DBRepository(
os.path.join(self.testdir, '__repository__'))
self.rep.open()
self.manager = \
ParcelManager.get(self.rep.view, \
path=[os.path.join(self.rootdir, 'parcels')])
def _find(self, path):
return self.rep.findPath(path)
def loadParcel(self, namespace):
self.loadParcels([namespace])
def loadParcels(self, namespaces=None):
self.manager.loadParcels(namespaces)
if namespaces:
for namespace in namespaces:
parcelItem = self.manager.lookup(namespace)
self.assert_(parcelItem)
# print "Loaded namespace %s as item %s" % \
# (namespace, parcelItem.itsPath)
_KIND_KIND = Path("//Schema/Core/Kind")
_ITEM_KIND = Path("//Schema/Core/Item")
# Repository specific assertions
def assertIsRoot(self, item):
self.assert_(item in list(self.rep.iterRoots()))
def assertItemPathEqual(self, item, string):
self.assertEqual(str(item.itsPath), string)
