def test_commit_ok(self, makePSNodeMock, manageAffiliationsMock, manageSubscriptionsMock): makePSNodeMock.side_effect = utils.good_side_effect(self.name) 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): makePSNodeMock.assert_called_once_with(self.jid, self.name, self.psclient) manageAffiliationsMock.assert_called_once_with( self.jid, self.name, self.pubs, self.admins, self.psclient.xmlstream, True ) manageSubscriptionsMock.assert_called_once_with( self.jid, self.name, self.subs, self.psclient.xmlstream ) d.addCallback(cb) return d
def test__process(self): s = dict() self.chdlr._parse_iq = Mock(return_value=s) self.chdlr._manage_state = Mock(return_value=s) iq = self.iq response = xmlstream.toResponse(iq) 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.good_side_effect('Committed stuff')) self.pageMngr.reset = Mock() self.stateMngr.reset = Mock() d = self.chdlr._process(iq) def cb(msg): self.chdlr._parse_iq.assert_called_once_with(iq) self.chdlr._manage_state.assert_called_once_with(s) self.chdlr._make_next_iq.assert_called_once_with(iq, s) self.assertEquals(msg, response) d.addCallback(cb) return d
def test_handleDistribution_combiningNewRunId(self): name = 'name' old_dist = defaultdict(int) for i in xrange(10): old_dist[i] = i self.dm.distributions[1] = sim.Distributions(dict({name: old_dist})) params = sim.Parameters(run_id=2, cmd='results') new_dist = defaultdict(int) for i in xrange(10): new_dist[i] = i progress = sim.Progress(200) self.dm.checkStopCondition = Mock(return_value=False) 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, new_dist, progress) def check(data): for run_id in xrange(1,2): for k, v in self.dm.distributions[run_id].histograms[name].iteritems(): #old_dist and new_dist should not have combined self.assertEquals(v, k) self.assertFalse(self.dm._errback.called) d.addCallback(check) self.sch.clock.pump([1,1,1]) return d
def test_onGotDistribution(self): self.dm.broadcastLogs = Mock() self.dm.handleDistribution = Mock(side_effect=utils.good_side_effect('lush')) 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() progress = sim.Progress(200) params_el.addChild(progress.toElement()) dist = sim.Distributions() hist = defaultdict(int) hist[1] = 1 hist[2] = 2 dist.combine('a', hist) params_el.addChild(dist.toElement()) item.addChild(params_el) lg = sim.Logger() d = self.dm.onGotDistribution(params, item, lg) def check(data): self.assertFalse(self.dm.broadcastLogs.called) self.assertEquals(self.dm.handleDistribution.call_count, 1) self.assertFalse(self.dm._errback.called) d.addCallback(check) self.sch.clock.pump([1,1,1]) return d
def test_handleDistribution_notStopping(self): name = 'name' params = sim.Parameters(run_id='1', cmd='results') distribution = defaultdict(int) for i in xrange(10): distribution[i] = i progress = sim.Progress(200) self.dm.checkStopCondition = Mock(return_value=False) self.dm.broadcastResults = Mock() self.dm.broadcastStop = Mock() 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.assertFalse(self.dm.broadcastResults.called) self.assertFalse(self.dm.broadcastStop.called) self.dm.broadcastProgress.assert_called_once_with(params, progress) d.addCallback(check) self.sch.clock.pump([1,1,1]) 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_manageAffiliations_OnlyIgnoredAdmins(self, makeAffiliationsMock, getAffiliationsMock): getAffiliationsMock.side_effect = utils.good_side_effect({}) makeAffiliationsMock.side_effect = utils.good_side_effect('lush') sender = self.sender name = 'name' xsMock = Mock() d = sm.manageAffiliations(sender, name, [], [self.sender.full()], xsMock) def cb(msg): getAffiliationsMock.assert_called_once_with(sender=sender, node=name, xs=xsMock) self.assertEquals(makeAffiliationsMock.call_count, 0) d.addCallback(cb) return d
def setUp(self): c = Command(node='input', action='execute') self.cmd_in = self.iq() self.cmd_in.addChild(c.toElement()) self.getRegistered = Mock(side_effect=utils.good_side_effect(set(['master.local', 'mini.local']))) self.getComponents = Mock(side_effect=utils.good_side_effect(collab.COLLAB_COMPONENTS)) psnodes = disco.DiscoItems() [psnodes.append(disco.DiscoItem(testJid, nid)) for nid in set(['master.local', 'mini.local'])] self.getPSNodes = Mock(side_effect=utils.good_side_effect(psnodes)) self.people = ['*****@*****.**', '*****@*****.**'] jids = disco.DiscoItems() [jids.append(disco.DiscoItem(jid.JID(j))) for j in self.people] self.getAdmins = self.getPubs = self.getSubs = Mock(side_effect=utils.good_side_effect(jids))
def test_onGotStartSimulation_noPortfolio(self): run_id = '1' item = Element((pubsub.NS_PUBSUB_EVENT, 'item')) item['id'] = str(run_id) params = sim.Parameters(run_id=run_id, cmd='info') params_el = item.addChild(params.toElement()) logger = sim.Logger() self.cds.broadcastLogs = Mock(side_effect=utils.good_side_effect('done')) self.cds.broadcastResults = Mock() self.cds.simulatorFactory = MagicMock() self.cds._errback = Mock() gen = self.cds.onGotStartSimulation(params, item, logger) d = gen.next() def check(data): self.cds.broadcastLogs.assert_called_once_with(logger, params) self.assertFalse(self.cds.broadcastResults.called) self.assertFalse(self.cds.simulatorFactory.__getitem__.called) self.assertFalse(self.cds._errback.called) d.addCallback(check) self.assertRaises(StopIteration, gen.next) return d
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_getAffiliationsForJid_current(self, sendMock): xml = """ <iq type='result' from='pubsub.shakespeare.lit' to='*****@*****.**' id='affil1'> <pubsub xmlns='http://jabber.org/protocol/pubsub'> <affiliations> <affiliation node='node1' affiliation='owner'/> <affiliation node='node2' affiliation='publisher'/> <affiliation node='node5' affiliation='outcast'/> <affiliation node='node6' affiliation='owner'/> </affiliations> </pubsub> </iq> """ el = parseXml(xml) sendMock.side_effect = utils.good_side_effect(el) xs = Mock() d = psaff.getAffiliationsForJid(jid.JID('*****@*****.**'), xs) def cb(affs): expected = { 'node1': 'owner', 'node2': 'publisher', 'node5': 'outcast', 'node6': 'owner' } self.assertEquals(expected, affs) sendMock.assert_called_once_with(xs) d.addCallback(cb) return d
def test_getAffiliations_current(self, sendMock): xml = """ <iq type='result' from='pubsub.shakespeare.lit' to='[email protected]/elsinore' id='ent1'> <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'> <affiliations node='princely_musings'> <affiliation jid='*****@*****.**' affiliation='owner'/> <affiliation jid='*****@*****.**' affiliation='outcast'/> </affiliations> </pubsub> </iq> """ el = parseXml(xml) sendMock.side_effect = utils.good_side_effect(el) xs = Mock() d = psaff.getAffiliations(jid.JID('[email protected]/elsinore'), 'princely_musings', xs) def cb(affs): expected = { jid.internJID('*****@*****.**').userhostJID(): 'owner', jid.internJID('*****@*****.**').userhostJID(): 'outcast', } self.assertEquals(expected, affs) sendMock.assert_called_once_with(xs) d.addCallback(cb) return d
def setUp(self): self.broadcaster = Mock(side_effect=utils.good_side_effect('lush')) self.makePortfolioMock = Mock(return_value='not important') self.dp = '0.01' self.corr = '0.02' self.num_issuers = '3' self.num_runs = '100'
def test_manageAffiliations_includeAdmin(self, makeAffiliationsMock, getAffiliationsMock): getAffiliationsMock.side_effect = utils.good_side_effect({}) makeAffiliationsMock.side_effect = utils.good_side_effect('lush') sender = self.sender name = 'name' xsMock = Mock() d = sm.manageAffiliations(sender, name, [], [self.sender.full()], xsMock, True) def cb(msg): new_affiliations = {collab.ADMIN_JID: 'owner'} getAffiliationsMock.assert_called_once_with(sender=sender, node=name, xs=xsMock) makeAffiliationsMock.assert_called_once_with( sender=sender, node=name, affiliations=new_affiliations, xs=xsMock ) d.addCallback(cb) return d
def test_manageAffiliations_OnlyAdmins(self, makeAffiliationsMock, getAffiliationsMock): getAffiliationsMock.side_effect = utils.good_side_effect({}) makeAffiliationsMock.side_effect = utils.good_side_effect('lush') sender = self.sender name = 'name' xsMock = Mock() d = sm.manageAffiliations(sender, name, [], self.admins, xsMock) def cb(msg): new_affiliations = dict([(p, 'owner') for p in self.admins]) getAffiliationsMock.assert_called_once_with(sender=sender, node=name, xs=xsMock) makeAffiliationsMock.assert_called_once_with( sender=sender, node=name, affiliations=new_affiliations, xs=xsMock ) d.addCallback(cb) return d
def test_addInput_alreadyThere(self): testNodes = ['1', '2', '3'] node = nodes.PSInputNode(testJid, self.mockPSClient) node.inputChannels = Mock(side_effect=utils.good_side_effect(testNodes)) yield node.addInput('2') self.assertFalse(self.mockPSClient.subscribe.called)
def test_removeInput_notThere(self): testNodes = ['1', '2', '3'] node = nodes.PSInputNode(testJid, self.mockPSClient) node.inputChannels = Mock(side_effect=utils.good_side_effect(testNodes)) yield node.removeInput('4') self.assertFalse(self.mockPSClient.unsubscribe.called)
def setUp(self): self.mockPSClient = Mock() self.mockPSClient.subscribe = Mock(side_effect=utils.good_side_effect('cool')) self.mockPSClient.unsubscribe = Mock(side_effect=utils.good_side_effect('cool')) self.subs = set([ ps.Subscription( nodeIdentifier='node1', subscriber='*****@*****.**', state='subscribed', subscriptionIdentifier=1 ), ps.Subscription( nodeIdentifier='node2', subscriber='*****@*****.**', state='subscribed', subscriptionIdentifier=2 ) ])
def test_getSubscriptionsForJid_current(self, sendMock): xml = """ <iq type='result' from='pubsub.shakespeare.lit' to='*****@*****.**' id='subscriptions1'> <pubsub xmlns='http://jabber.org/protocol/pubsub'> <subscriptions> <subscription node='node1' jid='*****@*****.**' subscription='subscribed'/> <subscription node='node2' jid='*****@*****.**' subscription='subscribed'/> <subscription node='node5' jid='*****@*****.**' subscription='unconfigured'/> <subscription node='node6' jid='*****@*****.**' subscription='subscribed' subid='123-abc'/> <subscription node='node6' jid='*****@*****.**' subscription='subscribed' subid='004-yyy'/> </subscriptions> </pubsub> </iq> """ el = parseXml(xml) sendMock.side_effect = utils.good_side_effect(el) xs = Mock() d = psaff.getSubscriptionsForJid(jid.JID('*****@*****.**'), xs) def cb(subs): actual = [a.toElement().toXml() for a in subs] expected = [ ps.Subscription( nodeIdentifier='node1', subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed'), ps.Subscription( nodeIdentifier='node2', subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed'), ps.Subscription( nodeIdentifier='node5', subscriber=jid.internJID('*****@*****.**').userhostJID(), state='unconfigured'), ps.Subscription( nodeIdentifier='node6', subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed', subscriptionIdentifier='123-abc'), ps.Subscription( nodeIdentifier='node6', subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed', subscriptionIdentifier='004-yyy'), ] self.assertEquals(len(actual), 5) for ex in expected: self.assertIn(ex.toElement().toXml(), actual) sendMock.assert_called_once_with(xs) d.addCallback(cb) return d
def test_commit_ok(self): self.psclient.deleteNode.side_effect = utils.good_side_effect('lush') sc = sm.DeletePubsubNodeStateChanger(self.psclient, self.jid) sc.data['name'] = self.names d = sc.commit() def cb(msg): self.assertEquals(self.psclient.deleteNode.call_count, 2) d.addCallback(cb) return d
def test_manageSubscriptions_newSubsOnly(self, makeSubscriptionsMock, getSubscriptionsMock): getSubscriptionsMock.side_effect = utils.good_side_effect(set()) makeSubscriptionsMock.side_effect = utils.good_side_effect('lush') sender = self.sender name = 'name' xsMock = Mock() d = sm.manageSubscriptions(sender, name, self.subscriptions, xsMock) def cb(msg): getSubscriptionsMock.assert_called_once_with(sender=sender, node=name, xs=xsMock) self.assertEquals(makeSubscriptionsMock.call_count, 1) args = makeSubscriptionsMock.call_args[1] self.assertEquals(args['sender'], sender) self.assertEquals(args['node'], name) self.assertEquals(args['xs'], xsMock) for s in args['subscriptions']: self.assertEquals(s.state, 'subscribed') self.assertTrue(s.subscriber == jid.JID('*****@*****.**') or jid.JID('*****@*****.**')) d.addCallback(cb) return d
def test_manageAffiliations_onlyOldAffiliations(self, makeAffiliationsMock, getAffiliationsMock): getAffiliationsMock.side_effect = utils.good_side_effect(self.old_affiliations) makeAffiliationsMock.side_effect = utils.good_side_effect('lush') sender = self.sender name = 'name' xsMock = Mock() d = sm.manageAffiliations(sender, name, [], [], xsMock) def cb(msg): getAffiliationsMock.assert_called_once_with(sender=sender, node=name, xs=xsMock) new_affiliations = { jid.JID('*****@*****.**').full(): 'none', jid.JID('*****@*****.**').full(): 'none', } makeAffiliationsMock.assert_called_once_with( sender=sender, node=name, affiliations=new_affiliations, xs=xsMock ) d.addCallback(cb) return d
def test_makePSNode_okName(self): name = 'ok name' self.psclient.createNode = Mock(side_effect=utils.good_side_effect('lush')) d = sm.makePSNode(self.sender, name, self.psclient) def cb(msg): self.assertEquals(msg, name) self.assertEquals(self.psclient.createNode.call_count, 1) d.addCallback(cb) return d
def test_commit_cannotManageSubscriptions(self, makePSNodeMock, manageAffiliationsMock, manageSubscriptionsMock): makePSNodeMock.side_effect = utils.good_side_effect('lush') manageAffiliationsMock.side_effect = utils.good_side_effect('lush') manageSubscriptionsMock.side_effect = utils.bad_side_effect(error.StanzaError('%s: bleergh' % self.__class__)) 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() # 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(makePSNodeMock.call_count, 1) self.assertEquals(manageAffiliationsMock.call_count, 1) self.assertEquals(manageSubscriptionsMock.call_count, 1)
def test_make_next_iq(self): self.pageMngr.next_page = Mock(side_effect=utils.good_side_effect(iq())) node = StartHandler('nodeTest', self.stateMngr, self.pageMngr) iq1 = self.iq d_iq2 = node._make_next_iq(iq1, None) def checkIt(iq2): self.assertTrue(self.pageMngr.next_page.called) self.assertEquals(iq2.toXml(), iq().toXml()) d_iq2.addCallback(checkIt) return d_iq2
def test_inputChannels_none(self, getSubsMock): getSubsMock.side_effect = utils.good_side_effect([]) xsMock = Mock() self.mockPSClient.xmlstream = xsMock node = nodes.PSInputNode(testJid, self.mockPSClient) d = node.inputChannels() def cb(subs): getSubsMock.assert_called_once_with(testJid, xsMock) self.assertEquals([], subs) d.addCallback(cb) return d
def test_getSubscriptions_current(self, sendMock): xml = """ <iq type='result' from='pubsub.shakespeare.lit' to='[email protected]/elsinore' id='subman1'> <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'> <subscriptions node='princely_musings'> <subscription jid='*****@*****.**' subscription='subscribed'/> <subscription jid='*****@*****.**' subscription='unconfigured'/> <subscription jid='*****@*****.**' subscription='subscribed' subid='123-abc'/> <subscription jid='*****@*****.**' subscription='subscribed' subid='004-yyy'/> </subscriptions> </pubsub> </iq> """ el = parseXml(xml) sendMock.side_effect = utils.good_side_effect(el) xs = Mock() d = psaff.getSubscriptions(jid.JID('[email protected]/elsinore'), 'princely_musings', xs) def cb(subs): actual = [a.toElement().toXml() for a in subs] expected = [ ps.Subscription( nodeIdentifier=None, subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed'), ps.Subscription( nodeIdentifier=None, subscriber=jid.internJID('*****@*****.**').userhostJID(), state='unconfigured'), ps.Subscription( nodeIdentifier=None, subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed', subscriptionIdentifier='123-abc'), ps.Subscription( nodeIdentifier=None, subscriber=jid.internJID('*****@*****.**').userhostJID(), state='subscribed', subscriptionIdentifier='004-yyy'), ] self.assertEquals(len(actual), 4) for ex in expected: self.assertIn(ex.toElement().toXml(), actual) sendMock.assert_called_once_with(xs) d.addCallback(cb) return d
def test__process_readyToCommitOK(self): self.chdlr._parse_iq = Mock() self.chdlr._manage_state = Mock() response = xmlstream.toResponse(self.iq) 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.good_side_effect('Committed stuff')) 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) d = self.chdlr._process(self.iq) d.addCallback(checkIt) 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_broadcastStart(self): cdm = CorrelatedDefaultsManager(testjid) cdm.outputNode.onOutput = Mock(side_effect=utils.good_side_effect('lush')) params = simulation.Parameters() port = portfolio.Portfolio('p1') out = yield cdm.broadcastStart(params, port) self.assertEquals(cdm.outputNode.onOutput.call_count, 1) expected = simulation.Parameters(cmd='start', timestamp=params.timestamp).toElement() expected.addChild(portfolio.Portfolio('p1').toElement()) for (a, dic) in cdm.outputNode.onOutput.call_args_list: self.assertEquals(expected.toXml(), dic['data'].toXml())