#!/usr/bin/env python
import time
import stat
import unittest
import datetime
import zope.interface
import atom.data
import gdata.blogger.data
import gdata.blogger.client
from bloggerfs import bloggerfs
from bloggerfs.bloggerfs import *
from bloggerfs.bloggerfs import _hook2, _registered2, globalRegistry
class TestUtils(unittest.TestCase):
def test_getType(self):
obj = object()
self.assertEqual(stat.S_IFREG, getType(obj))
d = DirNode(None, None)
self.assertEqual(stat.S_IFDIR, getType(d))
def test_dirEntry(self):
de1 = DirEntry('test', type=stat.S_IFDIR)
de2 = DirEntry('test2', type=stat.S_IFDIR)
self.failIfEqual(de1, de2)
de2.name = 'test'
self.assertEqual(de1, de2)
self.assertFalse(de1 == object())
self.assertFalse(de1 != de2)
def test_timeoutmixin(self):
class Test(TimeOutMixin, DirNode):
def __init__(self, a, b):
super(Test, self).__init__(a, b)
self._fake_children = {}
def getChildren(self):
return self._fake_children
mock = Test(None, None)
self.assertEqual(mock.children, {})
di = {'test': 'asdf'}
mock._fake_children = di
self.assertEqual(mock.children, {})
mock._tick = mock._tick - datetime.timedelta(seconds=mock.seconds+1)
self.assertEqual(mock.children, di)
class PublishedStub:
zope.interface.implements(IPublished)
published = time.time()
class UpdatedStub:
zope.interface.implements(IUpdated)
updated = time.time()
class TestUpdatedPublished(unittest.TestCase):
def setUp(self):
self.pstub = PublishedStub()
self.ustub = UpdatedStub()
def test_publishedInterface(self):
self.assertEqual(IPublished(self.pstub).published,
self.pstub.published)
self.failUnlessRaises(TypeError, IPublished, self.ustub)
def test_publishedHierarchy(self):
node = Node(None, self.pstub)
self.assertEqual(IPublished(node).published, self.pstub.published)
def test_updatedInterface(self):
self.assertEqual(IUpdated(self.ustub).updated,
self.ustub.updated)
self.failUnlessRaises(TypeError, IUpdated, self.pstub)
def test_updatedHierarchy(self):
node = Node(None, self.ustub)
self.assertEqual(IUpdated(node).updated, self.ustub.updated)
class TestNodes(unittest.TestCase):
def test_locate(self):
node = Node(None, None)
self.failUnlessRaises(NotImplementedError, node.locate, [])
def test_TextNode(self):
class Stub:
text = None
stub = Stub()
node = TextNode(stub, None)
self.assertEqual(node.text, '')
stub.text = 'asdf'
self.assertEqual(node.text, 'asdf')
def test_TextNodeAdapter(self):
s = 'asdf'
node = Node(None, None)
text = atom.data.Text(s)
for IFace in INode, IFileNode:
newnode = IFace((text, node))
self.assertEqual(newnode.text, s)
class TestFileNode(unittest.TestCase):
def setUp(self):
self.parent = UpdatedPublishedStub(None, None)
self.node = FileNode('test', self.parent)
def test_locate(self):
self.failUnlessRaises(AssertionError, self.node.locate, ['qwer'])
self.assertEqual(self.node, self.node.locate([]))
def test_getattr(self):
st = self.node.getattr()
self.assertEqual(st.st_mode, stat.S_IFREG | 0440)
self.assertEqual(st.st_size, 4)
def test_read(self):
self.assertEqual(self.node.read(1024, 0), 'test')
self.assertEqual(self.node.read(3, 0), 'tes')
def test_adaptation(self):
node = INode(('test', self.parent))
self.assertTrue(isinstance(node, FileNode), 'Adaptetion error, '
'unexpected class returned')
self.node = node
self.test_read()
self.test_getattr()
class UpdatedPublishedStub(DirNode):
zope.interface.implements(IPublished, IUpdated, INode)
published = time.time()
updated = time.time()
def getChildren(self):
return {'test': self}
class TestDirNode(unittest.TestCase):
def setUp(self):
self.node = UpdatedPublishedStub(None, None)
self.ln = ListNode(['a', ['b', 'c']], self.node)
def test_readdir1(self):
dir1 = list(self.node.readdir(0))
self.assertEqual(len(dir1), 3)
dir2 = [DirEntry('.', type=stat.S_IFDIR),
DirEntry('..', type=stat.S_IFDIR),
DirEntry('test', type=stat.S_IFDIR)]
self.assertEqual(dir1, dir2)
def test_readdir2(self):
c = DirEntry('.', type=stat.S_IFDIR)
p = DirEntry('..', type=stat.S_IFDIR)
d = DirEntry('0', type=stat.S_IFREG)
f = DirEntry('1', type=stat.S_IFDIR)
dir1 = list(self.ln.readdir(0))
self.assertEqual(len(dir1), 4)
dir2 = [c, p, f, d]
self.assertEqual(dir1, dir2)
def test_getattr(self):
st = self.node.getattr()
self.assertEqual(st.st_mode, stat.S_IFDIR | 0550)
def test_getChild(self):
self.failUnlessRaises(IOError, self.node.getChild, 'qwerty')
self.assertEqual(self.node.getChild('test'), self.node)
def test_locate(self):
self.assertEqual(self.node, self.node.locate([]))
self.failUnlessRaises(IOError, self.node.locate, ['non exists'])
self.assertEqual(self.node.locate(['test']), self.node)
def test_rmdir(self):
self.failUnlessRaises(IOError, self.node.rmdir)
class IR1(zope.interface.Interface):
pass
class IR2(zope.interface.Interface):
pass
class IP1(zope.interface.Interface):
pass
class R1:
zope.interface.implements(IR1)
class R2:
zope.interface.implements(IR2)
class P1:
zope.interface.implements(IP1)
class MultiAdapter:
def __init__(self, r1, r2):
self.r1, self.r2 = r1, r2
class TestAdaptation(unittest.TestCase):
def setUp(self):
self.p1 = P1()
self.r1 = R1()
self.r2 = R2()
def test_registerAdapter2(self):
registerAdapter2(MultiAdapter, (IR1, IR2), IP1)
self.assertEqual(_registered2(globalRegistry, IR1, IR2, IP1),
MultiAdapter)
def test_registerAdapter2BasicTypes(self):
registerAdapter2(MultiAdapter, (str, IR2), IP1)
ma1 = _hook2(IP1, ('123', R2()))
ma2 = IP1(('123', R2()))
for ma in ma1, ma2:
self.assertTrue(isinstance(ma, MultiAdapter))
self.assertTrue(isinstance(ma.r2, R2))
self.assertEqual(ma.r1, '123')
class FakePostNode:
original = gdata.blogger.data.BlogPost()
def get_blog_id(self):
return '123'
def get_post_id(self):
return '456'
class MockClient(gdata.blogger.client.BloggerClient):
buggy = False
def __init__(self):
self.comments = []
self.posts = []
self.updates = []
def post(self, entry, uri, auth_token=None, converter=None,
desired_class=None, **kwargs):
if self.buggy:
raise gdata.client.RequestError('buggybuggybuggy')
self.posts.append(entry)
def update(self, entry, auth_token=None, force=False, **kwargs):
if self.buggy:
raise gdata.client.RequestError('buggybuggybuggy')
self.updates.append(entry)
class TestAdd(unittest.TestCase):
def setUp(self):
self.client = bloggerfs.client = MockClient()
self.addcomment = AddCommentNode('', FakePostNode())
self.addlabel = AddLabelNode('', FakePostNode())
def tearDown(self):
bloggerfs.client = None
def test_writeOnly(self):
for node in self.addcomment, self.addlabel:
self.assertEqual(node.mode, 0220)
self.failUnlessRaises(IOError, node.read, 10, 0)
def test_addComment(self):
s = '1234'
self.addcomment.write(s, 0)
self.assertEqual(1, len(self.client.posts))
comment = self.client.posts[0]
self.assertEqual(comment.content.text, s)
def test_addLabel(self):
s = 'label'
self.addlabel.write(s, 0)
self.assertEqual(1, len(self.client.updates))
post = self.client.updates[0]
self.assertEqual(s, post.category[-1].term)
def test_requestError(self):
self.client.buggy = True
for method in self.test_addComment, self.test_addLabel:
self.failUnlessRaises(IOError, method)
if __name__ == '__main__':
try:
from bloggerfs.tests import main
main()
except ImportError:
unittest.main()
|