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())
