def test__process_readyToCommitNotOK_stanzaError(self):
self.chdlr._parse_iq = Mock()
self.chdlr._manage_state = Mock()
response = xmlstream.toResponse(iq())
response.addChild(cmd())
self.chdlr._make_next_iq = Mock(side_effect=utils.good_side_effect(response))
self.pageMngr.ready = Mock(return_value=True)
self.stateMngr.commit = Mock(side_effect=utils.bad_side_effect(error.StanzaError('%s: Committed fail' % self.__class__)))
self.pageMngr.reset = Mock()
self.stateMngr.reset = Mock()
def checkIt(msg):
self.assertTrue(self.pageMngr.ready.called)
self.assertTrue(self.stateMngr.commit.called)
self.assertTrue(self.pageMngr.reset.called)
self.assertTrue(self.stateMngr.reset.called)
self.assertEquals(msg, response)
self.assertTrue(msg.firstChildElement().firstChildElement().name, 'note')
d = self.chdlr._process(self.iq)
d.addCallback(checkIt)
return d
def test_handleDistribution_stoppingBadBroadcastStop(self):
name = 'name'
run_id = '1'
params = sim.Parameters(run_id=run_id, cmd='results')
distribution = defaultdict(int)
for i in xrange(10):
distribution[i] = i
progress = sim.Progress(200)
self.dm.checkStopCondition = Mock(return_value=True)
self.dm.broadcastResults = Mock(side_effect=utils.good_side_effect('lush'))
self.dm.broadcastStop = Mock(side_effect=utils.bad_side_effect(ValueError('%s: arrrgh' % self.__class__)))
self.dm.broadcastProgress = Mock(side_effect=utils.good_side_effect('lush'))
self.dm._errback = Mock(side_effect=utils.good_side_effect('err handled'))
d = self.dm.handleDistribution(params, name, distribution, progress)
def check(data):
self.dm.checkStopCondition.assert_called_once_with(params, progress.runs)
self.assertEquals(self.dm.broadcastResults.call_count, 1)
self.assertEquals(self.dm.broadcastStop.call_count, 1)
self.dm.broadcastProgress.assert_called_once_with(params, progress)
self.assertFalse(run_id in self.dm.stopped_runs)
self.assertTrue(self.dm._errback.called)
d.addCallback(check)
self.sch.clock.pump([1,1,1])
return d
def test_reloadAll_cantAddInput(self):
old_inputs = set(['1','2','3','4'])
self.node.addInput.side_effect = utils.bad_side_effect(ValueError('%s: addInput failed' % self.__class__))
loader = self._makeLoader()
d = loader.reloadAll(self.node, old_inputs)
def check(data):
self.assertEquals(data, set())
self.assertEquals(self.node.addInput.call_count, 4)
self.assertFalse(self.node.removeInput.called)
d.addCallback(check)
self.sch.clock.pump([1,1,1,1])
return d
def test_makePSNode_badName(self):
name = 'bad name'
self.psclient.createNode = Mock(side_effect=utils.bad_side_effect(error.StanzaError(
condition='conflict', text='%s: not lush' % self.__class__)))
d = sm.makePSNode(self.sender, name, self.psclient, 3)
def cb(msg):
self.assertTrue(False)
def eb(msg):
self.assertNotEquals(msg, name)
self.assertEquals(self.psclient.createNode.call_count, 3)
d.addCallbacks(cb, eb)
return d
def test_suspendAll_cantRemoveInput(self):
inputs = set(['1','2','3','4'])
self.node.inputChannels = Mock(side_effect=utils.good_side_effect(inputs))
self.node.removeInput.side_effect = utils.bad_side_effect(ValueError('%s: removeInput failed' % self.__class__))
loader = self._makeLoader()
d = loader.suspendAll(self.node)
def check(data):
self.assertEquals(self.node.inputChannels.call_count, 1)
self.assertEquals(data, set())
self.assertEquals(self.node.removeInput.call_count, 4)
self.assertFalse(self.node.addInput.called)
d.addCallback(check)
self.sch.clock.pump([1,1,1,1])
return d
def test_onError_toPublishErrored(self):
self.mockPSClient.publish = Mock(side_effect=utils.bad_side_effect(error.StanzaError('DISAPPOINTED')))
errors = ['errornode1', 'errornode2', 'log']
node = nodes.PSErrorNode(testJid, self.mockPSClient)
node.errorChannels = Mock(side_effect=utils.good_side_effect(errors))
el = Element(('top', 'ns'))
el.addContent('im covered in bees')
el.toXml = Mock()
d = node.onError(el)
def cb(msg):
self.assertEquals(self.mockPSClient.publish.call_count, 2)
self.assertEquals(el.toXml.call_count, 1)
d.addCallback(cb)
return self.assertFailure(d, error.StanzaError)
def test_commit_cannotManageSubscriptions(self, manageAffiliationsMock, manageSubscriptionsMock):
manageAffiliationsMock.side_effect = utils.good_side_effect('lush')
manageSubscriptionsMock.side_effect = utils.bad_side_effect(error.StanzaError('%s: bleergh' % self.__class__))
sc = sm.ConfigPubsubNodeStateChanger(self.psclient, self.jid)
sc.data['name'] = self.name
sc.data['admins'] = self.admins
sc.data['publishers'] = self.pubs
sc.data['subscribers'] = self.subs
d = sc.commit()
# d is a deferredlist with errors in it so collect all
# garbage and then check that the expected error is there
# then make sure that the other stuff still happened
gc.collect()
self.assertEquals(len(self.flushLoggedErrors(error.StanzaError)), 1)
self.assertEquals(manageAffiliationsMock.call_count, 1)
self.assertEquals(manageSubscriptionsMock.call_count, 1)
def test__process_makeNextIqThrows(self):
self.chdlr._parse_iq = Mock()
self.chdlr._manage_state = Mock()
self.chdlr._make_next_iq = Mock(side_effect=utils.bad_side_effect(PageManagerError('%s: Massive corn clog in port seven' % self.__class__)))
iq = self.iq
d = self.chdlr._process(iq)
self.assertTrue(self.chdlr._parse_iq.called)
self.assertTrue(self.chdlr._manage_state.called)
self.assertTrue(self.chdlr._make_next_iq.called)
def cb(msg):
f = failure.Failure('%s: Massive corn clog in port seven' % self.__class__, PageManagerError)
err = makeErr(str(f), iq)
self.assertEquals(msg.toXml(), err.toXml())
d.addCallback(cb)
return d
def test_onGotDistribution_noProgress_badBroadcast(self):
self.dm.broadcastLogs = Mock(side_effect=utils.bad_side_effect(Exception('%s: groan' % self.__class__)))
self.dm.handleDistribution = Mock()
self.dm._errback = Mock(side_effect=utils.good_side_effect('err logged'))
item = Element((pubsub.NS_PUBSUB_EVENT, 'item'))
item['id'] = str(1)
params = sim.Parameters(run_id='1', cmd='results')
params_el = params.toElement()
params_el.addChild(sim.Distributions().toElement())
item.addChild(params_el)
lg = sim.Logger()
d = self.dm.onGotDistribution(params, item, lg)
def check(data):
self.assertFalse(self.dm.handleDistribution.called)
self.assertEquals(self.dm.broadcastLogs.call_count, 1)
self.assertEquals(self.dm._errback.call_count, 1)
d.addCallback(check)
self.sch.clock.pump([1,1,1])
return d
def test_commit_cannotCreatePSNode(self, makePSNodeMock, manageAffiliationsMock, manageSubscriptionsMock):
makePSNodeMock.side_effect = utils.bad_side_effect(error.StanzaError('%s: bleergh' % self.__class__))
manageAffiliationsMock.side_effect = utils.good_side_effect('lush')
manageSubscriptionsMock.side_effect = utils.good_side_effect('lush')
sc = sm.CreatePubsubNodeStateChanger(self.psclient, self.jid)
sc.data['component'] = self.comp
sc.data['name'] = self.name
sc.data['admins'] = self.admins
sc.data['publishers'] = self.pubs
sc.data['subscribers'] = self.subs
d = sc.commit()
def cb(ret):
self.assertTrue(False)
def eb(err):
self.assertEquals(makePSNodeMock.call_count, 1)
self.assertEquals(manageAffiliationsMock.call_count, 0)
self.assertEquals(manageSubscriptionsMock.call_count, 0)
d.addCallbacks(cb, eb)
return d
def test__process_readyToCommitNotOK_otherError(self):
self.chdlr._parse_iq = Mock()
self.chdlr._manage_state = Mock()
response = xmlstream.toResponse(iq())
response.addChild(cmd())
self.chdlr._make_next_iq = Mock(side_effect=utils.good_side_effect(response))
self.pageMngr.ready = Mock(return_value=True)
self.stateMngr.commit = Mock(side_effect=utils.bad_side_effect(ValueError('%s: Committed fail' % self.__class__)))
self.pageMngr.reset = Mock()
self.stateMngr.reset = Mock()
def checkIt(msg):
self.assertTrue(self.pageMngr.ready.called)
self.assertTrue(self.stateMngr.commit.called)
self.assertTrue(self.pageMngr.reset.called)
self.assertTrue(self.stateMngr.reset.called)
self.assertNotEquals(msg, response)
d = self.chdlr._process(self.iq)
d.addCallbacks(lambda _: self.assertTrue(False), checkIt)
return d
