def test_failAll(self):
sent = ListLog()
def sendQANFrame(frame):
sent.append(frame)
h = QANHelper(None, None, sendQANFrame, None)
d1 = h.ask("going to the theater?")
d2 = h.ask("mu?")
self.assertEqual([
Question("going to the theater?", 1),
Question("mu?", 2),
], sent.getNew())
h.failAll("just because")
self.assertTrue(d1.called)
d1_ = self.assertFailure(d1, QuestionFailed)
d1_.addCallback(lambda e: self.assertEqual("just because", str(e)))
assert d1_.called
self.assertTrue(d2.called)
d2_ = self.assertFailure(d2, QuestionFailed)
d2_.addCallback(lambda e: self.assertEqual("just because", str(e)))
assert d2_.called
# Peer can still send an answer to the failed Questions
h.handleQANFrame(OkayAnswer("no", 1))
h.handleQANFrame(KnownErrorAnswer("what?", 2))
def test_repr(self):
h = QANHelper(None, None, lambda _: None, None)
self.assertEqual("<QANHelper asked 0 questions, waiting for 0 "
"peer answers and 0 local answers>", repr(h))
h.ask("what?")
self.assertEqual("<QANHelper asked 1 questions, waiting for 1 "
"peer answers and 0 local answers>", repr(h))
def test_weCancel(self):
sent = ListLog()
def sendQANFrame(frame):
sent.append(frame)
h = QANHelper(None, None, sendQANFrame, None)
d = h.ask("going to the theater?")
self.assertEqual([
Question("going to the theater?", 1),
], sent.getNew())
d.cancel()
self.assertEqual([
Cancellation(1),
], sent.getNew())
self.assertTrue(d.called)
d2 = self.assertFailure(d, defer.CancelledError)
assert d2.called
# Peer always sends an answer, which QANHelper must ignore.
h.handleQANFrame(OkayAnswer("nope", 1))
def test_ask(self):
sent = ListLog()
def sendQANFrame(frame):
sent.append(frame)
answers = ListLog()
def gotOkayAnswer(answer):
answers.append((answer, 'okay'))
def gotErrorAnswerExpect(expectedFailure):
def gotErrorAnswer(failure):
failure.trap(expectedFailure)
answers.append((failure.value[0], 'error'))
return gotErrorAnswer
fatalErrors = ListLog()
def fatalError(msg):
fatalErrors.append(msg)
h = QANHelper(None, None, sendQANFrame, fatalError)
d1 = h.ask("what?")
d1.addCallbacks(gotOkayAnswer, gotErrorAnswerExpect(None))
# Make sure QANHelper wrote something to the peer
self.assertEqual([
Question("what?", 1),
], sent.getNew())
# We shouldn't have an answer yet
self.assertEqual([], answers.getNew())
# An answer with a wrong QID calls fatalError
self.assertEqual([], fatalErrors.getNew())
h.handleQANFrame(OkayAnswer("answer with wrong qid", 100))
self.assertEqual(["Received an answer with invalid qid: 100"], fatalErrors.getNew())
### TODO: we might have to set up a new QANHelper after the fatalError;
### the current implementation is lenient.
# Feed this "OkayAnswer from the peer" into QANHelper
h.handleQANFrame(OkayAnswer("no.", 1))
self.assertEqual([('no.', 'okay')], answers.getNew())
d2 = h.ask("I want a KnownError response to this one")
d2.addCallbacks(gotOkayAnswer, gotErrorAnswerExpect(KnownError))
# Feed this "KnownErrorAnswer from the peer" into QANHelper
h.handleQANFrame(KnownErrorAnswer("KnownErrorAnswer as asked", 2))
self.assertEqual([('KnownErrorAnswer as asked', 'error')], answers.getNew())
d3 = h.ask("I want an UnknownError response to this one")
d3.addCallbacks(gotOkayAnswer, gotErrorAnswerExpect(UnknownError))
# Feed this "UnknownErrorAnswer from the peer" into QANHelper
h.handleQANFrame(UnknownErrorAnswer("UnknownErrorAnswer as asked", 3))
self.assertEqual([('UnknownErrorAnswer as asked', 'error')], answers.getNew())
