コード例 #1
0
class TestHandlerContainer(unittest.TestCase):

    def setUp(self):
        self.deployer = MockDeployer()
        self.deployer.deploy()

    def tearDown(self):
        self.deployer.clean()

    def container(self):
        return Container(MockDeployer.CONF_D, [MockDeployer.PATH])

    def test_loading(self):
        # Setup
        container = self.container()
        # Test
        container.load()
        # Verify
        handler = container.find('rpm')
        self.assertTrue(handler is not None)
        handler = container.find('srpm')
        self.assertTrue(handler is not None)
        handler = container.find('puppet')
        self.assertTrue(handler is None)
        handler = container.find('yum', BIND)
        self.assertTrue(handler is not None)
        handler = container.find('Linux', SYSTEM)
        self.assertTrue(handler is not None)
        errors = container.errors()
        self.assertEquals(len(errors), 3)
        self.assertTrue(isinstance(errors[0], ImportError))
        self.assertTrue(isinstance(errors[1], PropertyNotFound))
        self.assertTrue(isinstance(errors[2], SectionNotFound))

    def test_find(self):
        # Setup
        container = self.container()
        # Test
        container.load()
        handler = container.find('xxx')
        # Verify
        self.assertTrue(handler is None)
コード例 #2
0
class TestHandlerContainer(unittest.TestCase):

    def setUp(self):
        self.deployer = MockDeployer()
        self.deployer.deploy()

    def tearDown(self):
        self.deployer.clean()

    def container(self):
        return container.Container(MockDeployer.CONF_D, [MockDeployer.PATH])

    def test_loading(self):
        # Setup
        c = self.container()
        # Test
        c.load()
        # Verify
        handler = c.find('rpm')
        self.assertTrue(handler is not None)
        handler = c.find('srpm')
        self.assertTrue(handler is not None)
        handler = c.find('puppet')
        self.assertTrue(handler is None)
        handler = c.find('yum', container.BIND)
        self.assertTrue(handler is not None)
        handler = c.find('Linux', container.SYSTEM)
        self.assertTrue(handler is not None)
        errors = c.errors()
        self.assertEquals(len(errors), 3)
        self.assertTrue(isinstance(errors[0], ImportError))
        self.assertTrue(isinstance(errors[1], PropertyNotFound))
        self.assertTrue(isinstance(errors[2], SectionNotFound))

    def test_find(self):
        # Setup
        c = self.container()
        # Test
        c.load()
        handler = c.find('xxx')
        # Verify
        self.assertTrue(handler is None)
コード例 #3
0
class TestDispatcher(unittest.TestCase):

    def setUp(self):
        self.deployer = MockDeployer()
        self.deployer.deploy()

    def tearDown(self):
        self.deployer.clean()

    def container(self):
        return Container(MockDeployer.CONF_D, [MockDeployer.PATH])

    def test_install(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        report = dispatcher.install(conduit, units, options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 2)
        self.assertFalse(report.reboot['scheduled'])

    def test_install_failed(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        report = ContentReport()
        report.set_failed({'a':1})
        handler.install = Mock(return_value=report)
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.install(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertEqual(report.details['rpm']['details'], {'a':1})

    def test_install_raised(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        handler.install = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.install(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertTrue(report.details['rpm']['details'].has_key('message'))
        self.assertTrue(report.details['rpm']['details'].has_key('trace'))

    def test_install_reboot(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        options = dict(reboot=True)
        # Test
        conduit = Conduit()
        report = dispatcher.install(conduit, [unit], options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 2)
        self.assertTrue(report.reboot['scheduled'])

    def test_install_failed_no_handler(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='xxx',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        report = dispatcher.install(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 1)
        # RPM passed
        rpm = report.details['rpm']
        self.assertTrue(rpm['succeeded'])
        # XXX failed
        xxx = report.details['xxx']
        self.assertFalse(xxx['succeeded'])

    def test_update(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        report = dispatcher.update(conduit, units, options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 2)

    def test_update_failed(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        report = ContentReport()
        report.set_failed({'a':1})
        handler.update = Mock(return_value=report)
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.update(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertEqual(report.details['rpm']['details'], {'a':1})

    def test_update_raised(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        handler.update = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.update(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertTrue(report.details['rpm']['details'].has_key('message'))
        self.assertTrue(report.details['rpm']['details'].has_key('trace'))

    def test_uninstall(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        options = {}
        # Test
        conduit = Conduit()
        report = dispatcher.uninstall(conduit, [unit], options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 1)

    def test_uninstall_failed(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        report = ContentReport()
        report.set_failed({'a':1})
        handler.uninstall = Mock(return_value=report)
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.uninstall(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertEqual(report.details['rpm']['details'], {'a':1})

    def test_uninstall_raised(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = dispatcher.container.find('rpm')
        handler.uninstall = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        report = dispatcher.uninstall(conduit, units, options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.reboot['scheduled'])
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertTrue(report.details['rpm']['details'].has_key('message'))
        self.assertTrue(report.details['rpm']['details'].has_key('trace'))

    def test_profile(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        report = dispatcher.profile(conduit)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 0)

    def test_profile_failed(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find('rpm')
        report = ProfileReport()
        report.set_failed({'a':1})
        handler.profile = Mock(return_value=report)
        # Test
        conduit = Conduit()
        report = dispatcher.profile(conduit)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertEqual(report.details['rpm']['details'], {'a':1})

    def test_profile_raised(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find('rpm')
        handler.profile = Mock(side_effect=ValueError())
        # Test
        conduit = Conduit()
        report = dispatcher.profile(conduit)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        self.assertFalse(report.details['rpm']['succeeded'])
        self.assertTrue(report.details['rpm']['details'].has_key('message'))
        self.assertTrue(report.details['rpm']['details'].has_key('trace'))

    def test_reboot(self):
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        report = dispatcher.reboot(conduit, {})
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 0)

    def test_bind(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        report = dispatcher.bind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEqual(report.num_changes, 1)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertTrue(details['succeeded'])
        self.assertEqual(details['details'], {})

    def test_bind_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        report = BindReport(repo_id)
        report.set_failed({'a':1})
        handler.bind = Mock(return_value=report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        report = dispatcher.bind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a':1})

    def test_bind_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        handler.bind = Mock(side_effect=ValueError())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        report = dispatcher.bind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertTrue(details['details'].has_key('message'))
        self.assertTrue(details['details'].has_key('trace'))

    def test_unbind(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEqual(report.num_changes, 1)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertEqual(details['details'], {})

    def test_unbind_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        report = BindReport(repo_id)
        report.set_failed({'a':1})
        handler.unbind = Mock(return_value=report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a':1})

    def test_unbind_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        handler.unbind = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertTrue(details['details'].has_key('message'))
        self.assertTrue(details['details'].has_key('trace'))

    def test_unbind_all(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=None, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEqual(report.num_changes, 1)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertEqual(details['details'], {})

    def test_unbind_all_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        report = BindReport(repo_id)
        report.set_failed({'a':1})
        handler.unbind = Mock(return_value=report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a':1})

    def test_unbind_all_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        handler.unbind = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        report = dispatcher.unbind(conduit, [binding,], options)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEqual(report.num_changes, 0)
        details = report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertTrue(details['details'].has_key('message'))
        self.assertTrue(details['details'].has_key('trace'))

    def test_clean(self):
        type_id = 'yum'
        # Setup
        dispatcher = Dispatcher(self.container())
        # Test
        conduit = Conduit()
        report = dispatcher.clean(conduit)
        pprint(report.dict())
        self.assertTrue(report.succeeded)
        self.assertEquals(report.num_changes, 1)
        details = report.details[type_id]
        self.assertEqual(details['details'], {})

    def test_clean_failed(self):
        type_id = 'yum'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        report = CleanReport()
        report.set_failed({'a':1})
        handler.clean = Mock(return_value=report)
        # Test
        conduit = Conduit()
        report = dispatcher.clean(conduit)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        details = report.details[type_id]
        self.assertEqual(details['details'], {'a':1})

    def test_clean_raised(self):
        type_id = 'yum'
        # Setup
        dispatcher = Dispatcher(self.container())
        handler = dispatcher.container.find(type_id, BIND)
        handler.clean = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        report = dispatcher.clean(conduit)
        pprint(report.dict())
        self.assertFalse(report.succeeded)
        self.assertEquals(report.num_changes, 0)
        details = report.details[type_id]
        self.assertTrue(details['details'].has_key('message'))
        self.assertTrue(details['details'].has_key('trace'))
コード例 #4
0
class TestDispatcher(unittest.TestCase):

    def setUp(self):
        self.deployer = MockDeployer()
        self.deployer.deploy()

    def tearDown(self):
        self.deployer.clean()

    def container(self):
        return container.Container(MockDeployer.CONF_D, [MockDeployer.PATH])

    def test_install(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        _report = d.install(conduit, units, options)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 2)
        self.assertFalse(_report.reboot['scheduled'])

    def test_install_failed(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        _report = report.ContentReport()
        _report.set_failed({'a': 1})
        handler.install = Mock(return_value=_report)
        # Test
        options = {}
        conduit = Conduit()
        _report = d.install(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertEqual(_report.details['rpm']['details'], {'a': 1})

    def test_install_raised(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        handler.install = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        _report = d.install(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertTrue('message' in _report.details['rpm']['details'])
        self.assertTrue('trace' in _report.details['rpm']['details'])

    def test_install_reboot(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        options = dict(reboot=True)
        # Test
        conduit = Conduit()
        _report = d.install(conduit, [unit], options)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 2)
        self.assertTrue(_report.reboot['scheduled'])

    def test_install_failed_no_handler(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='xxx',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        _report = d.install(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 1)
        # RPM passed
        rpm = _report.details['rpm']
        self.assertTrue(rpm['succeeded'])
        # XXX failed
        xxx = _report.details['xxx']
        self.assertFalse(xxx['succeeded'])

    def test_update(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        options = {}
        # Test
        conduit = Conduit()
        _report = d.update(conduit, units, options)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 2)

    def test_update_failed(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        _report = report.ContentReport()
        _report.set_failed({'a': 1})
        handler.update = Mock(return_value=_report)
        # Test
        options = {}
        conduit = Conduit()
        _report = d.update(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertEqual(_report.details['rpm']['details'], {'a': 1})

    def test_update_raised(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        handler.update = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        _report = d.update(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertTrue('message' in _report.details['rpm']['details'])
        self.assertTrue('trace' in _report.details['rpm']['details'])

    def test_uninstall(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        options = {}
        # Test
        conduit = Conduit()
        _report = d.uninstall(conduit, [unit], options)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 1)

    def test_uninstall_failed(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        _report = report.ContentReport()
        _report.set_failed({'a': 1})
        handler.uninstall = Mock(return_value=_report)
        # Test
        options = {}
        conduit = Conduit()
        _report = d.uninstall(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertEqual(_report.details['rpm']['details'], {'a': 1})

    def test_uninstall_raised(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        units = []
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='zsh'))
        units.append(unit)
        unit = dict(
            type_id='rpm',
            unit_key=dict(name='ksh'))
        units.append(unit)
        handler = d.container.find('rpm')
        handler.uninstall = Mock(side_effect=ValueError())
        # Test
        options = {}
        conduit = Conduit()
        _report = d.uninstall(conduit, units, options)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.reboot['scheduled'])
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertTrue('message' in _report.details['rpm']['details'])
        self.assertTrue('trace' in _report.details['rpm']['details'])

    def test_profile(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        _report = d.profile(conduit)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)

    def test_profile_failed(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find('rpm')
        _report = report.ProfileReport()
        _report.set_failed({'a': 1})
        handler.profile = Mock(return_value=_report)
        # Test
        conduit = Conduit()
        _report = d.profile(conduit)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertEqual(_report.details['rpm']['details'], {'a': 1})

    def test_profile_raised(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find('rpm')
        handler.profile = Mock(side_effect=ValueError())
        # Test
        conduit = Conduit()
        _report = d.profile(conduit)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        self.assertFalse(_report.details['rpm']['succeeded'])
        self.assertTrue('message' in _report.details['rpm']['details'])
        self.assertTrue('trace' in _report.details['rpm']['details'])

    def test_reboot(self):
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        _report = d.reboot(conduit, {})
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)

    def test_bind(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        _report = d.bind(conduit, [binding], options)
        self.assertTrue(_report.succeeded)
        self.assertEqual(_report.num_changes, 1)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertTrue(details['succeeded'])
        self.assertEqual(details['details'], {})

    def test_bind_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        _report = report.BindReport(repo_id)
        _report.set_failed({'a': 1})
        handler.bind = Mock(return_value=_report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        _report = d.bind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a': 1})

    def test_bind_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        handler.bind = Mock(side_effect=ValueError())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id, details={})
        options = {}
        _report = d.bind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertTrue('message' in details['details'])
        self.assertTrue('trace' in details['details'])

    def test_unbind(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertTrue(_report.succeeded)
        self.assertEqual(_report.num_changes, 1)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertEqual(details['details'], {})

    def test_unbind_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        _report = report.BindReport(repo_id)
        _report.set_failed({'a': 1})
        handler.unbind = Mock(return_value=_report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a': 1})

    def test_unbind_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        handler.unbind = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertTrue('message' in details['details'])
        self.assertTrue('trace' in details['details'])

    def test_unbind_all(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        binding = dict(type_id=None, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertTrue(_report.succeeded)
        self.assertEqual(_report.num_changes, 1)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertEqual(details['details'], {})

    def test_unbind_all_failed(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        _report = report.BindReport(repo_id)
        _report.set_failed({'a': 1})
        handler.unbind = Mock(return_value=_report)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertEqual(details['details'], {'a': 1})

    def test_unbind_all_raised(self):
        type_id = 'yum'
        repo_id = 'repo-1'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        handler.unbind = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        binding = dict(type_id=type_id, repo_id=repo_id)
        options = {}
        _report = d.unbind(conduit, [binding], options)
        self.assertFalse(_report.succeeded)
        self.assertEqual(_report.num_changes, 0)
        details = _report.details[type_id][0]
        self.assertEqual(details['repo_id'], repo_id)
        self.assertFalse(details['succeeded'])
        self.assertTrue('message' in details['details'])
        self.assertTrue('trace' in details['details'])

    def test_clean(self):
        type_id = 'yum'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        # Test
        conduit = Conduit()
        _report = d.clean(conduit)
        self.assertTrue(_report.succeeded)
        self.assertEquals(_report.num_changes, 1)
        details = _report.details[type_id]
        self.assertEqual(details['details'], {})

    def test_clean_failed(self):
        type_id = 'yum'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        _report = report.CleanReport()
        _report.set_failed({'a': 1})
        handler.clean = Mock(return_value=_report)
        # Test
        conduit = Conduit()
        _report = d.clean(conduit)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        details = _report.details[type_id]
        self.assertEqual(details['details'], {'a': 1})

    def test_clean_raised(self):
        type_id = 'yum'
        # Setup
        d = dispatcher.Dispatcher(self.container())
        handler = d.container.find(type_id, container.BIND)
        handler.clean = Mock(side_effect=ValueError)
        # Test
        conduit = Conduit()
        _report = d.clean(conduit)
        self.assertFalse(_report.succeeded)
        self.assertEquals(_report.num_changes, 0)
        details = _report.details[type_id]
        self.assertTrue('message' in details['details'])
        self.assertTrue('trace' in details['details'])