def testCertifiedRemoteCall(self):
d = self._callRemote('authenticate', 'adim', 'adim')
cnxId, _ = unittest.deferredResult(d)
retValue = self._callRemote('lastIndexationTimeAndState', cnxId,
'foo.pdf')
self.assertEquals(unittest.deferredResult(retValue),
[0, Document.UNKNOWN_STATE])
def testRebind(self):
server = Server()
p = reactor.listenUDP(0, server, interface="127.0.0.1")
reactor.iterate()
unittest.deferredResult(defer.maybeDeferred(p.stopListening))
p = reactor.listenUDP(0, server, interface="127.0.0.1")
reactor.iterate()
unittest.deferredResult(defer.maybeDeferred(p.stopListening))
def test_check_connection(self):
"""command check"""
deferred = self.factory.check("check")
self.assertEquals(unittest.deferredResult(deferred),
"""False""")
self.factory.write("connect")
self.factory.write("bots.netofpeers.net:8555")
self._wait_for("Connected")
deferred = self.factory.check("check")
self.assertEquals(unittest.deferredResult(deferred),
"""True""")
def test_disconnect(self):
"""command disconnect"""
deferred = self.factory.check("disconnect")
self.assertEquals(unittest.deferredResult(deferred),
"""not connected""")
self.factory.write("connect")
self.factory.write("bots.netofpeers.net:8555")
self._wait_for("Connected")
deferred = self.factory.check("disconnect")
self.assertEquals(unittest.deferredResult(deferred),
"""Not connected""")
def test_jump(self):
"""command jump"""
deferred = self.factory.check("jump")
self.assertEquals(unittest.deferredResult(deferred),
"""[192.33.178.29:5010]""")
deferred = self.factory.check("")
self.assertEquals(unittest.deferredResult(deferred),
"""not connected""")
self.factory.write("connect")
self.factory.write("bots.netofpeers.net:8555")
self._wait_for("Connected")
self.factory.check("jump")
self.assertEquals(unittest.deferredResult(deferred),
"""192.33.178.29:5010""")
def test_simple(self):
doc = div[p['foo'],p['bar']]
result = unittest.deferredResult(
rend.Page(docFactory=loaders.stan(doc)).renderString()
)
self.assertEquals(result, '<div><p>foo</p><p>bar</p></div>')
def testRequestAvatarId(self):
db = checkers.PluggableAuthenticationModulesChecker()
conv = self._makeConv({1:'password', 2:'entry', 3:''})
creds = credentials.PluggableAuthenticationModules('testuser',
conv)
d = db.requestAvatarId(creds)
self.assertEquals(unittest.deferredResult(d), 'testuser')
def testRawAuthentication(self):
for user, passwd in [('adim', 'adim'), ('foo', 'bar')]:
digest = self._callRemote('authenticate', user, passwd)
expected = rpc.make_uid(user, passwd)
got, _ = unittest.deferredResult(digest)
self.assertEquals(got, expected, ('%s != %s (%s)' % (got, expected, _)))
self.assertEquals(_, '')
def test_go(self):
"""command go"""
deferred = self.factory.write("go")
deferred = self.factory.check("")
self.assertEquals(unittest.deferredResult(deferred),
"""2 parameters instead of 2, using default\nnot connected\n""")
self.factory.write("connect")
self.factory.write("bots.netofpeers.net:8555")
self._wait_for("Connected")
self.factory.write("go")
deferred = self.factory.check("")
self.assertEquals(unittest.deferredResult(deferred),
"""2 parameters instead of 2, using default\nmoved to 0.0,0.0\n""")
self.factory.write("go")
deferred = self.factory.check("0.25,0.43")
self.assertEquals(unittest.deferredResult(deferred),
"""moved to 0.25,0.43\n""")
def test_about(self):
"""command about"""
deferred = self.factory.check("about")
self.assertEquals(unittest.deferredResult(deferred),
"""Solipsis Navigator 0.1.1
Licensed under the GNU LGPL
(c) France Telecom R&D""")
def testDeferredWrapper(self):
from twisted.internet import defer
from twisted.internet import reactor
a = defer.Deferred()
reactor.callLater(0, lambda: a.callback("test"))
b = flow.Merge(a, slowlist([1,2,flow.Cooperate(),3]))
rhs = unittest.deferredResult(flow.Deferred(b))
self.assertEquals(rhs, [1, 2, 'test', 3])
def testCallback(self):
cb = flow.Callback()
d = flow.Deferred(buildlist(cb))
for x in range(9):
cb.result(x)
cb.finish()
rhs = unittest.deferredResult(d)
self.assertEquals([range(9)],rhs)
def testAnonymousAuthenticationFailure(self):
"""when portal.anonymousQuerier is None, anonymous login is not allowed"""
self.portal.anonymousQuerier = None
digest = self._callRemote('authenticate', '', '')
got, err = unittest.deferredResult(digest)
self.assertEquals(got, '')
# XXX: need a better check
self.assertNotEquals(err, '')
def testAnonymousAuthenticationFailure(self):
"""when portal.anonymousQuerier is None, anonymous login is not allowed"""
self.portal.anonymousQuerier = None
digest = self._callRemote('authenticate', '', '')
got, err = unittest.deferredResult(digest)
self.assertEquals(got, '')
# XXX: need a better check
self.assertNotEquals(err, '')
def testRawAuthentication(self):
for user, passwd in [('adim', 'adim'), ('foo', 'bar')]:
digest = self._callRemote('authenticate', user, passwd)
expected = rpc.make_uid(user, passwd)
got, _ = unittest.deferredResult(digest)
self.assertEquals(got, expected,
('%s != %s (%s)' % (got, expected, _)))
self.assertEquals(_, '')
def testProtocol(self):
from twisted.protocols import loopback
server = flow.Protocol()
server.controller = echoServer
client = flow.makeProtocol(echoClient)()
client.factory = protocol.ClientFactory()
client.factory.d = defer.Deferred()
loopback.loopback(server, client)
self.assertEquals('testing', unittest.deferredResult(client.factory.d))
def testRequestAvatarId(self):
dbfile = self.mktemp()
db = checkers.FilePasswordDB(dbfile, caseSensitive=0)
f = file(dbfile, 'w')
for (u, p) in self.users:
f.write('%s:%s\n' % (u, p))
f.close()
for (u, p) in self.users:
c = credentials.UsernamePassword(u, p)
d = defer.maybeDeferred(db.requestAvatarId, c)
self.assertEquals(unittest.deferredResult(d), u)
for (u, p) in self.users:
self.assertEquals(
unittest.deferredResult(db.requestAvatarId(
credentials.UsernameHashedPassword(u, p))),
u
)
def test_not_valid(self):
"""command not valid"""
# assert using 'deferredResult'
deferred = self.factory.check("dummy")
self.assertEquals(unittest.deferredResult(deferred),
"""do_dummy not a valid command""")
# assert using custom callback
deferred = self.factory.check("")
deferred.addCallback(self._assert_not_valid)
while not self.done:
reactor.iterate(0.1)
def testProtocolLocalhost(self):
PORT = 8392
server = protocol.ServerFactory()
server.protocol = flow.Protocol
server.protocol.controller = echoServer
reactor.listenTCP(PORT,server)
client = protocol.ClientFactory()
client.protocol = flow.makeProtocol(echoClient)
client.d = defer.Deferred()
reactor.connectTCP("localhost", PORT, client)
self.assertEquals('testing', unittest.deferredResult(client.d))
def deferredRender(res, req):
d = util.maybeDeferred(res.renderHTTP,
context.PageContext(
tag=res, parent=context.RequestContext(
tag=req)))
def done(result):
if isinstance(result, str):
req.write(result)
req.d.callback(req)
return result
d.addCallback(done)
return unittest.deferredResult(req.d, 1)
def deferredRender(res):
defres = req()
d = util.maybeDeferred(res.renderHTTP,
context.PageContext(
tag=res, parent=context.RequestContext(
tag=defres)))
def done(result):
if isinstance(result, str):
defres.write(result)
defres.d.callback(defres.accumulator)
return result
d.addCallback(done)
return unittest.deferredResult(defres.d, 1)
def test_display(self):
"""command display"""
deferred = self.factory.check("display")
self.assertEquals(unittest.deferredResult(deferred),
"""not connected""")
self.factory.write("connect")
self.factory.write("bots.netofpeers.net:8555")
self._wait_for("Connected")
# not using deferredResult here since it swallows timeout
deferred = self.factory.check("display")
deferred.addCallback(self._assert_display)
while not self.done:
reactor.iterate(0.1)
def deferredRender(res, req):
d = util.maybeDeferred(res.renderHTTP,
context.PageContext(
tag=res, parent=context.RequestContext(
tag=req)))
def done(result):
if isinstance(result, str):
req.write(result)
req.d.callback(req)
return result
d.addCallback(done)
return unittest.deferredResult(req.d, 1)
def test_help(self):
"""command help"""
deferred = self.factory.check("help")
self.assertEquals(unittest.deferredResult(deferred),
"""[all]""")
deferred = self.factory.check("")
self.assertEquals(unittest.deferredResult(deferred),
"""{'about': ['display general information', ''],
'check': ['chech status of connection', ''],
'connect': ['connect to specified node', 'bots.netofpeers.net:8551'],
'create': ['create Node', 'Guest'],
'disconnect': ['discoonnect from current node', ''],
'display': ['display current address', ''],
'go': ['go to position', '0,0'],
'help': ['display help [on cmd]', 'all'],
'hover': ['emumate hover on peer', '0,0'],
'jump': ['jump to node', '192.33.178.29:5010'],
'kill': ['kill node', ''],
'mem': ['dump a snapshot of memory (debugging tool)', ''],
'menu': ['display peer menu', ''],
'pref': ['change preferences', ''],
'quit': ['close navigator', '']}\n""")
def test_remembers(self):
class Page(rend.Page):
docFactory = loaders.stan(html[body[p(data=directive('foo'),
render=directive('bar'))]])
def data_foo(self, ctx, data):
return 'foo'
def render_bar(self, ctx, data):
return ctx.tag.clear()[data + 'bar']
result = unittest.deferredResult(Page().renderString())
self.assertEquals(result, '<html><body><p>foobar</p></body></html>')
def _disabled_testThreaded(self):
from time import sleep
#self.fail("This test freezes and consumes 100% CPU.")
class CountIterator:
def __init__(self, count):
self.count = count
def __iter__(self):
return self
def next(self): # this is run in a separate thread
sleep(.1)
val = self.count
if not(val):
raise StopIteration
self.count -= 1
return val
result = [7,6,5,4,3,2,1]
d = flow.Deferred(flow.Threaded(CountIterator(7)))
self.assertEquals(result, unittest.deferredResult(d))
d = flow.Deferred(flow.Threaded(CountIterator(7)))
sleep(2)
self.assertEquals(result, unittest.deferredResult(d))
d = flow.Deferred(flow.Threaded(CountIterator(7)))
sleep(.3)
self.assertEquals(result, unittest.deferredResult(d))
def test_remembers(self):
class Page(rend.Page):
docFactory = loaders.stan(
html[
body[
p(data=directive('foo'), render=directive('bar'))
]
]
)
def data_foo(self, ctx, data):
return 'foo'
def render_bar(self, ctx, data):
return ctx.tag.clear()[data+'bar']
result = unittest.deferredResult(Page().renderString())
self.assertEquals(result, '<html><body><p>foobar</p></body></html>')
def testRegister(self):
self.register()
dest, m = self.sent[0]
self.assertEquals((dest.host, dest.port), ("client.com", 5060))
self.assertEquals(m.code, 200)
self.assertEquals(m.headers["via"], ["SIP/2.0/UDP client.com:5060"])
self.assertEquals(m.headers["to"], ["sip:[email protected]"])
self.assertEquals(m.headers["contact"], ["sip:[email protected]:5060"])
self.failUnless(int(m.headers["expires"][0]) in (3600, 3601, 3599, 3598))
self.assertEquals(len(self.registry.users), 1)
dc, uri = self.registry.users["joe"]
self.assertEquals(uri.toString(), "sip:[email protected]:5060")
desturl = unittest.deferredResult(
self.proxy.locator.getAddress(sip.URL(username="******", host="bell.example.com")))
self.assertEquals((desturl.host, desturl.port), ("client.com", 5060))
def deferredRender(res):
defres = req()
d = util.maybeDeferred(
res.renderHTTP,
context.PageContext(tag=res,
parent=context.RequestContext(tag=defres)))
def done(result):
if isinstance(result, str):
defres.write(result)
defres.d.callback(defres.accumulator)
return result
d.addCallback(done)
return unittest.deferredResult(defres.d, 1)
def testConcurrentCallback(self):
ca = flow.Callback()
ca.name = 'a'
cb = flow.Callback()
cb.name = 'b'
d = flow.Deferred(testconcur(ca,cb))
ca.result(1)
cb.result(2)
ca.result(3)
ca.result(4)
ca.finish()
cb.result(5)
cb.finish()
rhs = unittest.deferredResult(d)
self.assertEquals([('a',1),('b',2),('a',3),('a',4),('b',5)],rhs)
def testHashedPasswords(self):
def hash(u, p, s):
return crypt(p, s)
dbfile = self.mktemp()
db = checkers.FilePasswordDB(dbfile, hash=hash)
f = file(dbfile, 'w')
for (u, p) in self.users:
f.write('%s:%s\n' % (u, crypt(p, u[:2])))
f.close()
r = TestRealm()
port = portal.Portal(r)
port.registerChecker(db)
for (u, p) in self.users:
c = credentials.UsernamePassword(u, p)
d = defer.maybeDeferred(db.requestAvatarId, c)
self.assertEquals(unittest.deferredResult(d), u)
d = port.login(c, None, ITestable)
i, a, l = unittest.deferredResult(d)
self.assertEquals(a.original.name, u)
# It should fail if we pass the wrong password
c = credentials.UsernamePassword(u, 'wrong password')
d = port.login(c, None, ITestable)
f = unittest.deferredError(d)
f.trap(error.UnauthorizedLogin)
# And it should fail for UsernameHashedPassword
c = credentials.UsernameHashedPassword(u, crypt(p, u[:2]))
d = port.login(c, None, ITestable)
f = unittest.deferredError(d)
f.trap(error.UnhandledCredentials)
def makePage(self, content):
_ = i18n.Translator(translator=mockTranslator)
page = rend.Page(
docFactory=loaders.stan(tags.invisible(render=tags.directive('i18n'))[content]))
page.render_i18n = i18n.render(_)
doc = page.docFactory.load()
ctx = context.WovenContext(context.PageContext(tag=page),
tags.invisible[doc])
page.rememberStuff(ctx)
io = StringIO()
writer = io.write
def finisher(result):
return io.getvalue()
d = page.flattenFactory(doc, ctx, writer, finisher)
r = unittest.deferredResult(d, 1)
return r
def testResults(self):
x = self.proxy().callRemote("add", 2, 3)
self.assertEquals(unittest.deferredResult(x), 5)
x = self.proxy().callRemote("kwargs", b=2, a=3)
self.assertEquals(unittest.deferredResult(x), 5)
x = self.proxy().callRemote("kwargs", b=3)
self.assertEquals(unittest.deferredResult(x), 4)
x = self.proxy().callRemote("defer", "a")
self.assertEquals(unittest.deferredResult(x), "a")
x = self.proxy().callRemote("dict", {"a" : 1}, "a")
self.assertEquals(unittest.deferredResult(x), 1)
x = self.proxy().callRemote("pair", 'a', 1)
self.assertEquals(unittest.deferredResult(x), ['a', 1, None])
x = self.proxy().callRemote("struct")
self.assertEquals(unittest.deferredResult(x)._asdict,
{"a": "c"})
x = self.proxy().callRemote("complex")
self.assertEquals(unittest.deferredResult(x)._asdict,
{"a": ["b", "c", 12, []], "D": "foo"})
def testResults(self):
x = self.proxy().callRemote("add", 2, 3)
self.assertEquals(unittest.deferredResult(x), 5)
x = self.proxy().callRemote("kwargs", b=2, a=3)
self.assertEquals(unittest.deferredResult(x), 5)
x = self.proxy().callRemote("kwargs", b=3)
self.assertEquals(unittest.deferredResult(x), 4)
x = self.proxy().callRemote("defer", "a")
self.assertEquals(unittest.deferredResult(x), "a")
x = self.proxy().callRemote("dict", {"a": 1}, "a")
self.assertEquals(unittest.deferredResult(x), 1)
x = self.proxy().callRemote("pair", 'a', 1)
self.assertEquals(unittest.deferredResult(x), ['a', 1, None])
x = self.proxy().callRemote("struct")
self.assertEquals(unittest.deferredResult(x)._asdict, {"a": "c"})
x = self.proxy().callRemote("complex")
self.assertEquals(
unittest.deferredResult(x)._asdict, {
"a": ["b", "c", 12, []],
"D": "foo"
})
def makePage(self, content):
_ = i18n.Translator(translator=mockTranslator)
page = rend.Page(
docFactory=loaders.stan(tags.invisible(render=tags.directive('i18n'))[content]))
page.render_i18n = i18n.render(_)
doc = page.docFactory.load()
ctx = context.WovenContext(context.PageContext(tag=page),
tags.invisible[doc])
page.rememberStuff(ctx)
io = StringIO()
writer = io.write
def finisher(result):
return io.getvalue()
d = page.flattenFactory(doc, ctx, writer, finisher)
r = unittest.deferredResult(d, 1)
return r
def testAnonymousAuthentication(self):
self.portal.anonymousQuerier = object() # could be anything but None
digest = self._callRemote('authenticate', '', '')
got, _ = unittest.deferredResult(digest)
self.assertEquals(_, '')
self.assertEquals(got, ANONYMOUS_AVATARID)
def testAnonymousAuthentication(self):
self.portal.anonymousQuerier = object() # could be anything but None
digest = self._callRemote('authenticate', '', '')
got, _ = unittest.deferredResult(digest)
self.assertEquals(_, '')
self.assertEquals(got, ANONYMOUS_AVATARID)
def testCertifiedRemoteCall(self):
d = self._callRemote('authenticate', 'adim', 'adim')
cnxId, _ = unittest.deferredResult(d)
retValue = self._callRemote('lastIndexationTimeAndState', cnxId, 'foo.pdf')
self.assertEquals(unittest.deferredResult(retValue), [0, Document.UNKNOWN_STATE])
def testUncertifiedRemoteCall(self):
"""only authentified people should be able to call remote methods"""
retValue = self._callRemote('lastIndexationTimeAndState', 'evil', 'foo.pdf')
self.assertEquals(unittest.deferredResult(retValue), [-1, Document.UNKNOWN_STATE])
def testRawAuthentication(self):
for user, passwd in [('adim', 'adim'), ('foo', 'bar')]:
digest = self._callRemote('authenticate', user, passwd)
expected = rpc.make_uid(user, passwd)
self.assertEquals(unittest.deferredResult(digest), expected)
def deferred_result(d):
"""
Shorcut to obtain more verbose errors
"""
d.addErrback(exception)
return deferredResult(d)
def testUncertifiedRemoteCall(self):
"""only authentified people should be able to call remote methods"""
retValue = self._callRemote('lastIndexationTime', 'evil', 'foo.pdf')
self.assertEquals(unittest.deferredResult(retValue), -1)
def testCertifiedRemoteCall(self):
d = self._callRemote('authenticate', 'adim', 'adim')
cnxId = unittest.deferredResult(d)
retValue = self._callRemote('lastIndexationTime', cnxId, 'foo.pdf')
self.assertEquals(unittest.deferredResult(retValue), 0)
def test_simple(self):
doc = div[p['foo'], p['bar']]
result = unittest.deferredResult(
rend.Page(docFactory=loaders.stan(doc)).renderString())
self.assertEquals(result, '<div><p>foo</p><p>bar</p></div>')
def getResource(root, path):
return unittest.deferredResult(
appserver.NevowSite(root).getPageContextForRequestContext(
context.RequestContext(tag=testutil.FakeRequest(uri=path))))
