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'))
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_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_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_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_uninstall_with_reboot(self):
# Setup
groups = ['plain']
units = [
dict(type_id=self.TYPE_ID, unit_key=dict(name=g)) for g in groups
]
# Test
conduit = Conduit()
options = {'reboot': True}
report = self.dispatcher.uninstall(conduit, units, options)
# Verify
self.verify_succeeded(report, removed=groups, reboot=True)
self.assertTrue(report.reboot['scheduled'])
self.assertEquals(report.reboot['details']['minutes'], 1)
os.system.assert_called_once_with('shutdown -r +1')
self.assertTrue(YumBase.processTransaction.called)
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)
self.assertEqual(report.details[type_id][repo_id]['details'], {})
def test_uninstall_noapply(self):
# Setup
groups = ['plain', 'pulp']
units = [
dict(type_id=self.TYPE_ID, unit_key=dict(name=g)) for g in groups
]
# Test
conduit = Conduit()
options = {'apply': False}
report = self.dispatcher.uninstall(conduit, units, options)
# Verify
self.verify_succeeded(report, removed=groups)
self.assertFalse(report.reboot['scheduled'])
self.assertFalse(report.reboot['scheduled'])
self.assertFalse(os.system.called)
self.assertFalse(YumBase.processTransaction.called)
def test_install_all_fields(self, mock_yum_install):
# Setup
units = [{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'zsh',
'epoch': '3',
'version': '2.2',
'release': '3.3',
'arch': 'x86_64'
}
}]
# Test
conduit = Conduit()
self.dispatcher.install(conduit, units, {})
mock_yum_install.assert_called_once_with(
pattern="3:zsh-2.2-3.3.x86_64")
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_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_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_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_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_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)
self.assertFalse(report.details[type_id][repo_id]['succeeded'])
self.assertEqual(report.details[type_id][repo_id]['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)
self.assertTrue(
report.details[type_id][repo_id]['details'].has_key('message'))
self.assertTrue(
report.details[type_id][repo_id]['details'].has_key('trace'))
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_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_update_with_reboot(self):
# Setup
units = [
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'zsh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'ksh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'gofer'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'okaara'
}
},
]
# Test
conduit = Conduit()
options = {'reboot': True, 'minutes': 5}
report = self.dispatcher.update(conduit, units, options)
# Verify
self.verify_succeeded(report, updated=units, reboot=True)
self.assertTrue(report.reboot['scheduled'])
self.assertEquals(report.reboot['details']['minutes'], 5)
os.system.assert_called_once_with('shutdown -r +5')
self.assertTrue(YumBase.processTransaction.called)
def test_update_importkeys(self):
# Setup
units = [
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'zsh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'ksh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'gofer'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'okaara'
}
},
]
# Test
conduit = Conduit()
options = {'importkeys': True}
report = self.dispatcher.update(conduit, units, options)
# Verify
self.verify_succeeded(report, updated=units)
self.assertFalse(report.reboot['scheduled'])
self.assertFalse(os.system.called)
self.assertTrue(YumBase.processTransaction.called)
def test_uninstall(self):
# Setup
units = [
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'zsh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'okaara'
}
},
]
# Test
conduit = Conduit()
report = self.dispatcher.uninstall(conduit, units, {})
# Verify
self.verify_succeeded(report, removed=units)
self.assertFalse(report.reboot['scheduled'])
self.assertFalse(os.system.called)
self.assertTrue(YumBase.processTransaction.called)
def test_install_notfound(self):
# Setup
units = [
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'zsh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'ksh'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': 'gofer'
}
},
{
'type_id': self.TYPE_ID,
'unit_key': {
'name': YumBase.UNKNOWN_PKG
}
},
]
# Test
conduit = Conduit()
report = self.dispatcher.install(conduit, units, {})
# Verify
self.verify_failed(report)
self.assertFalse(report.reboot['scheduled'])
self.assertFalse(os.system.called)
self.assertFalse(YumBase.processTransaction.called)
