def test_group_modify_group_name(self):
group_name = 'mynewgroup'
out = run_client(['bkr', 'group-modify',
'--group-name', group_name,
self.group.group_name],
config = self.client_config)
with session.begin():
session.refresh(self.group)
group = Group.by_name(group_name)
self.assertEquals(group.group_name, group_name)
self.assertEquals(group.activity[-1].action, u'Changed')
self.assertEquals(group.activity[-1].field_name, u'Name')
self.assertEquals(group.activity[-1].user.user_id,
self.user.user_id)
self.assertEquals(group.activity[-1].new_value, group_name)
self.assertEquals(group.activity[-1].service, u'XMLRPC')
try:
out = run_client(['bkr', 'group-modify',
'--group-name', 'areallylonggroupname'*20,
self.group.group_name],
config = self.client_config)
self.fail('Must fail or die')
except ClientError,e:
max_length = Group.group_name.property.columns[0].type.length
self.assertRegexpMatches(e.stderr_output,
'Enter a value (less|not more) than %r characters long' % max_length)
def test_remove_and_add(self):
b = self.browser
self.assert_(any(lca.lab_controller == self.lc
for lca in self.distro_tree.lab_controller_assocs))
#Remove
b.get(get_server_base() + 'labcontrollers/')
b.find_element_by_xpath('//tr[normalize-space(string(td[1]))="%s"]'
'//a[contains(text(), "Remove")]' % self.lc.fqdn).click()
self.assertEquals(b.find_element_by_class_name('flash').text,
'%s removed' % self.lc)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.lab_controller is None)
session.refresh(self.distro_tree)
self.assert_(not any(lca.lab_controller == self.lc
for lca in self.distro_tree.lab_controller_assocs))
#Re add
b.get(get_server_base() + 'labcontrollers/')
b.find_element_by_xpath('//tr[normalize-space(string(td[1]))="%s"]'
'//a[contains(text(), "Re-Add")]' % self.lc.fqdn).click()
self.assertEquals(b.find_element_by_class_name('flash').text,
'Successfully re-added %s' % self.lc)
def test_add_group(self):
with session.begin():
group = data_setup.create_group()
user_password = "******"
user = data_setup.create_user(password=user_password)
data_setup.add_user_to_group(user, group)
orig_date_modified = self.system.date_modified
# as admin, assign the system to our test group
self.login()
sel = self.selenium
self.go_to_system_view()
sel.click('//ul[@class="tabbernav"]//a[text()="Groups"]')
sel.type("groups_group_text", group.group_name)
sel.click('//form[@name="groups"]//a[text()="Add ( + )"]')
sel.wait_for_page_to_load("30000")
self.assertEquals(
sel.get_xpath_count(
'//div[normalize-space(@class)="tabbertab"]' '//td[normalize-space(text())="%s"]' % group.group_name
),
1,
)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
# as a user in the group, can we see it?
self.logout()
self.login(user.user_name, user_password)
sel.click("link=Available")
sel.wait_for_page_to_load("30000")
sel.type("simplesearch", self.system.fqdn)
sel.submit("systemsearch_simple")
sel.wait_for_page_to_load("30000")
self.failUnless(sel.is_text_present(self.system.fqdn))
def test_can_add_tag_to_distro(self):
self.server.auth.login_password(
data_setup.ADMIN_USER, data_setup.ADMIN_PASSWORD)
self.server.distros.tag(self.distro.name, 'HAPPY')
with session.begin():
session.refresh(self.distro)
self.assert_(u'HAPPY' in self.distro.tags)
def test_system_pools_import(self):
with session.begin():
system = data_setup.create_system()
pool1 = data_setup.create_system_pool()
pool2 = data_setup.create_system_pool()
login(self.browser)
self.import_csv((u'csv_type,fqdn,pool,deleted\n'
u'system_pool,%s,%s,False\n'
u'system_pool,%s,%s,False'%(system.fqdn, pool1.name,
system.fqdn, pool2.name)) \
.encode('utf8'))
self.failUnless(is_text_present(self.browser, 'No Errors'))
with session.begin():
session.refresh(system)
self.assertEquals([pool1.name, pool2.name],
[pool.name for pool in system.pools])
# test deletion
self.import_csv((u'csv_type,fqdn,pool,deleted\n'
u'system_pool,%s,%s,True' % (system.fqdn, pool2.name)) \
.encode('utf8'))
self.failUnless(is_text_present(self.browser, 'No Errors'))
with session.begin():
session.refresh(system)
self.assertNotIn(pool2.name, [pool.name for pool in system.pools])
# Attempting to add a system to a Non existent pool should throw an error
self.import_csv((u'csv_type,fqdn,pool,deleted\n'
u'system_pool,%s,poolpool,True' % system.fqdn) \
.encode('utf8'))
self.assertTrue(is_text_present(self.browser, 'poolpool: pool does not exist'))
def test_activity_is_not_logged_when_leaving_power_settings_empty(self):
# The bug was that we were recording a change to power_user or
# power_passwd because it changed from NULL to ''.
with session.begin():
self.system.power.power_type = PowerType.lazy_create(name=u'ilo')
self.system.power.power_user = None
self.system.power.power_passwd = None
self.system.power.power_id = None
PowerType.lazy_create(name=u'drac')
self.assertEquals(len(self.system.activity), 0)
b = self.browser
login(b)
self.go_to_system_view(tab='Power Settings')
tab = b.find_element_by_id('power-settings')
# change power type but leave the other fields empty
BootstrapSelect(tab.find_element_by_name('power_type'))\
.select_by_visible_text('drac')
tab.find_element_by_tag_name('form').submit()
tab.find_element_by_xpath('.//span[@class="sync-status" and not(text())]')
with session.begin():
session.refresh(self.system)
self.assertEquals(len(self.system.activity), 1,
'Expecting only one activity row for power_type but found: %r'
% self.system.activity)
self.assertEquals(self.system.activity[0].field_name, u'power_type')
def test_delete_install_options(self):
with session.begin():
self.system.provisions[self.distro_tree.arch] = Provision(
arch=self.distro_tree.arch, ks_meta=u'some_ks_meta_var=1',
kernel_options=u'some_kernel_option=1',
kernel_options_post=u'some_kernel_option=2')
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Install Options')
delete_and_confirm(b, '//tr[th/text()="Architecture"]')
b.find_element_by_xpath('//h1[text()="%s"]' % self.system.fqdn)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
self.assert_(self.distro_tree.arch not in self.system.provisions)
self.assertEquals(self.system.activity[0].action, u'Removed')
self.assertEquals(self.system.activity[0].field_name,
u'InstallOption:kernel_options_post:i386')
self.assertEquals(self.system.activity[1].action, u'Removed')
self.assertEquals(self.system.activity[1].field_name,
u'InstallOption:kernel_options:i386')
self.assertEquals(self.system.activity[2].action, u'Removed')
self.assertEquals(self.system.activity[2].field_name,
u'InstallOption:ks_meta:i386')
def test_new_power_settings(self):
with session.begin():
lc = data_setup.create_labcontroller()
system = data_setup.create_system(lab_controller=lc,
with_power=False)
b = self.browser
login(b)
self.go_to_system_view(system=system, tab='Power Settings')
tab = b.find_element_by_id('power-settings')
BootstrapSelect(tab.find_element_by_name('power_type'))\
.select_by_visible_text('virsh')
tab.find_element_by_name('power_address').send_keys \
('qemu+ssh:10.10.10.10')
tab.find_element_by_name('power_user').send_keys('root')
tab.find_element_by_name('power_id').send_keys(system.fqdn)
tab.find_element_by_tag_name('form').submit()
# check activity records
power_fields_changed = {'power_type': 'virsh',
'power_address': 'qemu+ssh:10.10.10.1',
'power_user': '******',
'power_id': system.fqdn,
'power_quiescent_period': 5}
with session.begin():
session.refresh(system)
for activity in system.activity:
self.assertEquals(activity.new_value,
power_fields_changed[activity])
def test_update_labinfo(self):
with session.begin():
# Due to bz987313 system must have existing lab info
self.system.labinfo = LabInfo(weight=100)
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Lab Info')
changes = {
'orig_cost': '1,000.00',
'curr_cost': '500.00',
'dimensions': '1x1x1',
'weight': '50',
'wattage': '500',
'cooling': '1',
}
for k, v in changes.iteritems():
b.find_element_by_name(k).clear()
b.find_element_by_name(k).send_keys(v)
b.find_element_by_xpath('//button[text()="Save Lab Info Changes"]').click()
self.assertEquals(b.find_element_by_class_name('flash').text,
'Saved Lab Info')
for k, v in changes.iteritems():
self.assertEquals(b.find_element_by_name(k).get_attribute('value'), v)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def test_can_remove_tag_from_distro(self):
self.server.auth.login_password(
data_setup.ADMIN_USER, data_setup.ADMIN_PASSWORD)
self.server.distros.untag(self.distro.name, 'SAD')
with session.begin():
session.refresh(self.distro)
self.assert_(u'SAD' not in self.distro.tags)
def test_group_modify_add_member(self):
with session.begin():
user = data_setup.create_user()
out = run_client(['bkr', 'group-modify',
'--add-member', user.user_name,
self.group.group_name],
config = self.client_config)
with session.begin():
session.refresh(self.group)
group = Group.by_name(self.group.group_name)
self.assert_(user.user_name in
[u.user_name for u in group.users])
self.check_notification(user, group, action='Added')
try:
out = run_client(['bkr', 'group-modify',
'--add-member', 'idontexist',
self.group.group_name],
config = self.client_config)
self.fail('Must fail or die')
except ClientError, e:
self.assert_('User does not exist' in
e.stderr_output, e.stderr_output)
def test_system_export_reimport(self):
login(self.browser)
orig_date_modified = self.system.date_modified
self.import_csv(''.join([row for row in self.get_csv('system')]))
self.failUnless(is_text_present(self.browser, "No Errors"))
session.refresh(self.system)
self.assert_(orig_date_modified != self.system.date_modified)
def test_tag_distro(self):
with session.begin():
self.distro = data_setup.create_distro()
run_client(["bkr", "distros-tag", "--name", self.distro.name, "LOL"])
with session.begin():
session.refresh(self.distro)
self.assert_(u"LOL" in self.distro.tags)
def test_group_modify_group_name(self):
group_name = u'mynewgroup'
out = run_client(['bkr', 'group-modify',
'--group-name', group_name,
self.group.group_name],
config = self.client_config)
with session.begin():
session.refresh(self.group)
group = Group.by_name(group_name)
self.assertEquals(group.group_name, group_name)
self.assertEquals(group.activity[-1].action, u'Changed')
self.assertEquals(group.activity[-1].field_name, u'Name')
self.assertEquals(group.activity[-1].user.user_id,
self.user.user_id)
self.assertEquals(group.activity[-1].new_value, group_name)
self.assertEquals(group.activity[-1].service, u'HTTP')
try:
out = run_client(['bkr', 'group-modify',
'--group-name', 'areallylonggroupname'*20,
self.group.group_name],
config = self.client_config)
self.fail('Must fail or die')
except ClientError,e:
self.assertIn(
'Group name must be not more than 255 characters long',
e.stderr_output)
def test_update_system(self):
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Details')
tab = b.find_element_by_id('details')
tab.find_element_by_xpath('.//button[contains(text(), "Edit")]').click()
modal = b.find_element_by_class_name('modal')
changes = {
'vendor': 'Sinclair',
'model': 'ZX80',
'serial_number': '12345',
'mac_address': 'aa:bb:cc:dd:ee:ff',
}
for k, v in changes.iteritems():
modal.find_element_by_name(k).clear()
modal.find_element_by_name(k).send_keys(v)
modal.find_element_by_xpath('.//button[text()="Save changes"]').click()
tab.find_element_by_xpath('.//tr[th/text()="Vendor" and td/text()="Sinclair"]')
tab.find_element_by_xpath('.//tr[th/text()="Model" and td/text()="ZX80"]')
tab.find_element_by_xpath('.//tr[th/text()="Serial Number" and td/text()="12345"]')
tab.find_element_by_xpath('.//tr[th/text()="MAC Address" and td/text()="aa:bb:cc:dd:ee:ff"]')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def test_change_status(self):
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Scheduler Settings')
tab = b.find_element_by_id('scheduler-settings')
BootstrapSelect(tab.find_element_by_name('status'))\
.select_by_visible_text('Broken')
tab.find_element_by_xpath('.//button[text()="Save Changes"]').click()
b.find_element_by_xpath('//span[@class="label label-warning"'
' and text()="Out of service"]')
with session.begin():
session.refresh(self.system)
self.assertEqual(self.system.status, SystemStatus.broken)
self.assertEqual(len(self.system.status_durations), 2)
self.assertEqual(self.system.status_durations[0].status,
SystemStatus.broken)
assertions.assert_datetime_within(
self.system.status_durations[0].start_time,
tolerance=datetime.timedelta(seconds=60),
reference=datetime.datetime.utcnow())
self.assert_(self.system.status_durations[0].finish_time is None)
self.assert_(self.system.status_durations[1].finish_time is not None)
assertions.assert_durations_not_overlapping(
self.system.status_durations)
self.assert_(self.system.date_modified > orig_date_modified)
def test_remove_and_add(self):
sel = self.selenium
self.assert_(any(lca.lab_controller == self.lc
for lca in self.distro_tree.lab_controller_assocs))
#Remove
sel.open("labcontrollers/")
sel.wait_for_page_to_load('30000')
sel.click("//a[@onclick=\"has_watchdog('%s')\"]" % self.lc.id)
sel.wait_for_page_to_load("30000")
self.failUnless(sel.is_text_present("exact:%s removed" % self.lc))
with session.begin():
session.refresh(self.system)
self.assert_(self.system.lab_controller is None)
session.refresh(self.distro_tree)
self.assert_(not any(lca.lab_controller == self.lc
for lca in self.distro_tree.lab_controller_assocs))
#Re add
sel.open("labcontrollers/")
sel.wait_for_page_to_load('30000')
sel.click("//a[@href='unremove?id=%s']" % self.lc.id)
sel.wait_for_page_to_load('30000')
self.failUnless(sel.is_text_present("Succesfully re-added %s" % self.lc.fqdn))
def test_system(self):
login(self.browser)
orig_date_modified = self.system.date_modified
self.import_csv((u'csv_type,fqdn,location,arch\n'
u'system,%s,Under my desk,ia64' % self.system.fqdn)
.encode('utf8'))
self.failUnless(is_text_present(self.browser, "No Errors"))
with session.begin():
session.refresh(self.system)
self.assertEquals(self.system.location, u'Under my desk')
self.assert_(Arch.by_name(u'ia64') in self.system.arch)
self.assert_(self.system.date_modified > orig_date_modified)
# attempting to import a system with no FQDN should fail
self.import_csv((u'csv_type,fqdn,location,arch\n'
u'system,'',Under my desk,ia64').encode('utf8'))
self.assertEquals(self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text,
"Error importing line 2: "
"System must have an associated FQDN")
# attempting to import a system with an invalid FQDN should fail
self.import_csv((u'csv_type,fqdn,location,arch\n'
u'system,invalid--fqdn,Under my desk,ia64').encode('utf8'))
self.assertEquals(self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text,
"Error importing line 2: "
"Invalid FQDN for system: invalid--fqdn")
def test_add_cc(self):
with session.begin():
self.system.cc = []
b = self.browser
login(b)
self.go_to_system_view(tab='Owner')
tab = b.find_element_by_id('owner')
tab.find_element_by_name('cc').send_keys('*****@*****.**')
tab.find_element_by_class_name('cc-add').submit()
tab.find_element_by_xpath('.//li[contains(text(), "*****@*****.**")]')
tab.find_element_by_name('cc').send_keys('*****@*****.**')
tab.find_element_by_class_name('cc-add').submit()
tab.find_element_by_xpath('.//li[contains(text(), "*****@*****.**")]')
tab.find_element_by_xpath('.//li[contains(text(), "*****@*****.**")]')
with session.begin():
session.refresh(self.system)
self.assertEquals(set(self.system.cc),
set([u'*****@*****.**', u'*****@*****.**']))
self.assertEquals(self.system.activity[0].field_name, u'Cc')
self.assertEquals(self.system.activity[0].service, u'HTTP')
self.assertEquals(self.system.activity[0].action, u'Added')
self.assertEquals(self.system.activity[0].new_value, u'*****@*****.**')
self.assertEquals(self.system.activity[1].field_name, u'Cc')
self.assertEquals(self.system.activity[1].service, u'HTTP')
self.assertEquals(self.system.activity[1].action, u'Added')
self.assertEquals(self.system.activity[1].new_value, u'*****@*****.**')
def test_add_group(self):
with session.begin():
group = data_setup.create_group()
user_password = '******'
user = data_setup.create_user(password=user_password)
data_setup.add_user_to_group(user, group)
orig_date_modified = self.system.date_modified
# as admin, assign the system to our test group
b = self.browser
login(b)
self.go_to_system_view(tab='Groups')
b.find_element_by_name('group.text').send_keys(group.group_name)
b.find_element_by_name('groups').submit()
b.find_element_by_xpath(
'//div[@id="groups"]'
'//td[normalize-space(text())="%s"]' % group.group_name)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
# as a user in the group, can we see it?
logout(b)
login(b, user.user_name, user_password)
click_menu_item(b, 'Systems', 'Available')
b.find_element_by_name('simplesearch').send_keys(self.system.fqdn)
b.find_element_by_name('systemsearch_simple').submit()
check_system_search_results(b, present=[self.system])
def test_tag_distro(self):
with session.begin():
self.distro = data_setup.create_distro()
run_client(['bkr', 'distros-tag', '--name', self.distro.name, 'LOL'])
with session.begin():
session.refresh(self.distro)
self.assert_(u'LOL' in self.distro.tags)
def test_system_activity_shows_changes_for_disk(self):
with session.begin():
system=data_setup.create_system()
self.server.push(system.fqdn, {'Disk': {'Disks': [{'model': 'Virtio Block Device',
'phys_sector_size': 512,
'sector_size': 512,
'size': str(8589934592)}]}})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].field_name, u'Disk:model')
self.assertEquals(system.activity[0].new_value, u'Virtio Block Device')
self.assertEquals(system.activity[1].service, u'XMLRPC')
self.assertEquals(system.activity[1].action, u'Added')
self.assertEquals(system.activity[1].field_name, u'Disk:phys_sector_size')
self.assertEquals(system.activity[1].new_value, u'512')
self.assertEquals(system.activity[2].service, u'XMLRPC')
self.assertEquals(system.activity[2].action, u'Added')
self.assertEquals(system.activity[2].field_name, u'Disk:sector_size')
self.assertEquals(system.activity[2].new_value, u'512')
self.assertEquals(system.activity[3].service, u'XMLRPC')
self.assertEquals(system.activity[3].action, u'Added')
self.assertEquals(system.activity[3].field_name, u'Disk:size')
self.assertEquals(system.activity[3].new_value, u'8589934592')
def review(self, recipeset, response='Nak', comment='fnord'):
b = self.browser
rs = b.find_element_by_xpath('//*[@id="RS_%s"]' % recipeset.id)
# click response radio button
rs.find_element_by_xpath('.//label[normalize-space(string(.))="%s"]/input'
% response).click()
rs.find_element_by_xpath('.//span[text()="Success"]')
# click comment link
rs.find_element_by_link_text('comment').click()
# click edit button in modal
b.find_element_by_xpath('//*[contains(@class, "ui-dialog")]'
'//button[text()="Edit"]').click()
# type comment
textarea = b.find_element_by_xpath('//*[contains(@class, "ui-dialog")]//textarea')
textarea.clear()
textarea.send_keys(comment)
# click save button in modal
b.find_element_by_xpath('//*[contains(@class, "ui-dialog")]'
'//button[text()="Save"]').click()
rs.find_element_by_xpath('.//span[text()="Comment saved"]')
with session.begin():
session.refresh(recipeset)
self.assertEquals(unicode(recipeset.nacked.response).lower(),
response.lower())
self.assertEquals(recipeset.nacked.comment, comment)
def test_release_system(self):
with session.begin():
system = data_setup.create_system(
owner=User.by_user_name(data_setup.ADMIN_USER),
status=u'Manual', shared=True)
user = data_setup.create_user(password=u'password')
system.reserve_manually(service=u'testdata', user=user)
server = self.get_server()
server.auth.login_password(user.user_name, 'password')
server.systems.release(system.fqdn)
with session.begin():
session.refresh(system)
session.refresh(system.reservations[0])
self.assert_(system.user is None)
self.assertEquals(system.reservations[0].user, user)
assert_datetime_within(system.reservations[0].finish_time,
tolerance=datetime.timedelta(seconds=10),
reference=datetime.datetime.utcnow())
assert_durations_not_overlapping(system.reservations)
released_activity = system.activity[0]
self.assertEqual(released_activity.action, 'Returned')
self.assertEqual(released_activity.field_name, 'User')
self.assertEqual(released_activity.user, user)
self.assertEqual(released_activity.old_value, user.user_name)
self.assertEqual(released_activity.new_value, '')
self.assertEqual(released_activity.service, 'XMLRPC')
def test_untag_distro(self):
with session.begin():
self.distro = data_setup.create_distro(tags=[u'RELEASED', u'STABLE'])
run_client(['bkr', 'distros-untag', '--name', self.distro.name, 'RELEASED'])
with session.begin():
session.refresh(self.distro)
self.assertEquals(self.distro.tags, [u'STABLE'])
def test_system_page(self):
sel = self.selenium
sel.open('view/%s' % self.system.fqdn)
sel.wait_for_page_to_load('30000')
lcs = sel.get_text('//form//table/tbody/tr[10]') #The Lab Controller td
self.failUnless('%s' % self.lc.fqdn in lcs)
self.failUnless(self.system.lab_controller is self.lc)
# Remove it
sel.open("labcontrollers/")
sel.wait_for_page_to_load('30000')
sel.click("//a[@onclick=\"has_watchdog('%s')\"]" % self.lc.id)
sel.wait_for_page_to_load("30000")
sel.open('view/%s' % self.system.fqdn)
sel.wait_for_page_to_load('30000')
lcs = sel.get_text('//form//table/tbody/tr[10]')
self.failUnless('%s' % self.lc.fqdn not in lcs)
with session.begin():
session.refresh(self.system)
self.failUnless(not self.system.lab_controller)
# Re add it
sel.open("labcontrollers/")
sel.wait_for_page_to_load('30000')
sel.click("//a[@href='unremove?id=%s']" % self.lc.id)
sel.wait_for_page_to_load('30000')
sel.open('edit/%s' % self.system.fqdn)
sel.wait_for_page_to_load('30000')
sel.select("form_lab_controller_id", "label=%s" % self.lc.fqdn)
sel.click("link=Save Changes")
sel.wait_for_page_to_load('30000')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.lab_controller is self.lc)
def test_update_power(self):
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Power Settings')
tab = b.find_element_by_id('power-settings')
tab.find_element_by_name('power_address').clear()
tab.find_element_by_name('power_address').send_keys('nowhere.example.com')
tab.find_element_by_name('power_user').clear()
tab.find_element_by_name('power_user').send_keys('asdf')
tab.find_element_by_name('power_password').clear()
tab.find_element_by_name('power_password').send_keys('meh')
tab.find_element_by_name('power_quiescent_period').clear()
tab.find_element_by_name('power_quiescent_period').send_keys('66')
b.find_element_by_xpath('//label[normalize-space(string(.))="LeaveOn"]'
'/input[@type="radio"]').click()
old_address = self.system.power.power_address
old_quiescent = self.system.power.power_quiescent_period
tab.find_element_by_tag_name('form').submit()
tab.find_element_by_xpath('.//span[@class="sync-status" and not(text())]')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
self.assertEqual(self.system.power.power_quiescent_period, 66)
self.assertEqual(self.system.power.power_address,
'nowhere.example.com')
self.assertEqual(self.system.power.power_user, 'asdf')
self.assertEqual(self.system.power.power_passwd, 'meh')
self.assertEqual(self.system.release_action,
ReleaseAction.leave_on)
activities_to_find = ['power_address', 'power_quiescent_period',
'power_passwd', 'power_user', 'release_action']
for activity in self.system.activity:
if activity.field_name == 'power_passwd':
# Can't actually test what the activity entry is
activities_to_find.remove(activity.field_name)
if activity.field_name == 'power_user':
# Can't actually test what the activity entry is
activities_to_find.remove(activity.field_name)
if activity.field_name == 'power_address':
activities_to_find.remove(activity.field_name)
self.assertEqual(activity.old_value, old_address)
self.assertEqual(activity.new_value, 'nowhere.example.com')
if activity.field_name == 'power_quiescent_period':
activities_to_find.remove(activity.field_name)
self.assertEqual(activity.old_value, str(5))
self.assertEqual(activity.new_value, str(66))
if activity.field_name == 'release_action':
activities_to_find.remove(activity.field_name)
self.assertEqual(activity.old_value, 'PowerOff')
self.assertEqual(activity.new_value, 'LeaveOn')
if activities_to_find:
raise AssertionError('Could not find activity entries for %s' % ' '.join(activities_to_find))
def test_edit_distro_version(self):
with session.begin():
distro = data_setup.create_distro()
run_client(["bkr", "distros-edit-version", "--name", distro.name, "SillyVersion2.1"])
with session.begin():
session.refresh(distro)
self.assertEquals(distro.osversion.osmajor.osmajor, u"SillyVersion2")
self.assertEquals(distro.osversion.osminor, u"1")
def test_hypervisor_kvm(self):
with session.begin():
system = data_setup.create_system()
system.hypervisor = None
self.server.push(system.fqdn, {'Hypervisor': u'KVM'})
with session.begin():
session.refresh(system)
self.assertEquals(system.hypervisor.hypervisor, u'KVM')
def test_memory_is_updated(self):
with session.begin():
system = data_setup.create_system()
system.memory = 4096
self.server.push(system.fqdn, {'memory': '1024'})
with session.begin():
session.refresh(system)
self.assertEquals(system.memory, 1024)
def test_can_add_tag_to_distro(self):
b = self.browser
login(b, data_setup.ADMIN_USER, data_setup.ADMIN_PASSWORD)
go_to_distro_view(b, self.distro)
b.find_element_by_id('tags_tag_text').send_keys('HAPPY')
b.find_element_by_link_text('Add').click()
self.assertEquals(b.find_element_by_class_name('flash').text,
'Added Tag HAPPY')
b.find_element_by_xpath(
'//td[normalize-space(text())="HAPPY"]')
with session.begin():
session.refresh(self.distro)
activity = self.distro.activity[0]
self.assertEquals(activity.field_name, u'Tag')
self.assertEquals(activity.service, u'WEBUI')
self.assertEquals(activity.action, u'Added')
self.assertEquals(activity.old_value, None)
self.assertEquals(activity.new_value, u'HAPPY')
def test_clear_running_commands(self):
with session.begin():
system = data_setup.create_system(lab_controller=self.lc)
command = CommandActivity(
user=None, service=u'testdata', action=u'on',
status=CommandStatus.running)
system.command_queue.append(command)
other_system = data_setup.create_system()
other_command = CommandActivity(
user=None, service=u'testdata', action=u'on',
status=CommandStatus.running)
other_system.command_queue.append(other_command)
self.server.auth.login_password(self.lc.user.user_name, u'logmein')
self.server.labcontrollers.clear_running_commands(u'Staleness')
with session.begin():
session.refresh(command)
self.assertEquals(command.status, CommandStatus.aborted)
self.assertEquals(other_command.status, CommandStatus.running)
def test_system_activity_shows_changes_for_simple_attributes(self):
with session.begin():
system = data_setup.create_system()
system.vendor = None
system.model = None
system.memory = None
self.server.push(system.fqdn,
{'vendor': 'Acorn', 'model': 'Archimedes', 'memory': '16'})
with session.begin():
session.refresh(system)
# no way to know in which order the changes will be recorded :-(
changes = system.activity[:4]
for change in changes:
self.assertEquals(change.service, u'XMLRPC')
self.assertEquals(change.action, u'Changed')
changed_fields = set(change.field_name for change in changes)
self.assertEquals(changed_fields,
set(['checksum', 'vendor', 'model', 'memory']))
def test_install_failure_is_not_reported_after_installation_is_finished(
self):
anaconda_success = 'blah blah installing... done\n'
open(self.console_log, 'w').write(anaconda_success)
wait_for_condition(self.check_console_log_registered)
wait_for_condition(
lambda: self.check_cached_log_contents(anaconda_success))
with session.begin():
data_setup.mark_recipe_installation_finished(self.recipe)
data_setup.mark_recipe_running(self.recipe, only=True)
anaconda_failure = "Press 'OK' to reboot your system.\n"
open(self.console_log, 'a').write(anaconda_failure)
wait_for_condition(lambda: self.check_cached_log_contents(
anaconda_success + anaconda_failure))
with session.begin():
task = self.recipe.tasks[0]
session.refresh(task)
self.assertEquals(task.status, TaskStatus.running)
def test_mac_address_with_unicode(self):
bad_mac_address = u'aяяяяяяяяяяяяяяяяя'
b = self.browser
login(b)
self.go_to_system_view(tab='Details')
tab = b.find_element_by_id('details')
tab.find_element_by_xpath(
'.//button[contains(text(), "Edit")]').click()
modal = b.find_element_by_class_name('modal')
modal.find_element_by_name('mac_address').clear()
modal.find_element_by_name('mac_address').send_keys(bad_mac_address)
modal.find_element_by_xpath('.//button[text()="Save changes"]').click()
tab.find_element_by_xpath(
'.//tr[th/text()="MAC Address" and td/text()="%s"]' %
bad_mac_address)
with session.begin():
session.refresh(self.system)
self.assertEqual(self.system.mac_address, bad_mac_address)
def test_device_with_no_firmware(self):
with session.begin():
system = data_setup.create_system()
self.server.push(
system.fqdn, {
'Devices': [{
'type': None,
'bus': u'pci',
'driver': u'noclass',
'description': u'Oh so very tacky',
'vendorID': None,
'deviceID': None,
'subsysVendorID': None,
'subsysDeviceID': None
}]
})
with session.begin():
session.refresh(system)
self.assertEquals(system.devices[0].fw_version, None)
def test_system_activity_shows_changes_for_devices(self):
with session.begin():
system = data_setup.create_system()
self.server.push(system.fqdn, {'Devices': [{
'type': 'IDE', 'bus': u'pci', 'driver': u'PIIX_IDE',
'vendorID': '8086', 'deviceID': '7111',
'description': u'82371AB/EB/MB PIIX4 IDE',
'subsysVendorID': '0000', 'subsysDeviceID': '0000',
}]})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].field_name, u'Device')
self.assertEquals(system.activity[0].old_value, None)
# the new value will just be some random device id
self.assertEquals(system.activity[1].service, u'XMLRPC')
self.assertEquals(system.activity[1].action, u'Changed')
self.assertEquals(system.activity[1].field_name, u'checksum')
def test_bools_are_coerced_to_ints(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.append(
Key_Value_String(Key.by_name(u'HVM'), '0'))
self.server.legacypush(system.fqdn, {'HVM': False})
with session.begin():
session.refresh(system)
self.assertEquals(len(system.activity), 0) # nothing has changed, yet
self.server.legacypush(system.fqdn, {'HVM': True})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].field_name, u'Key/Value')
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].old_value, None)
self.assertEquals(system.activity[0].new_value, u'HVM/1')
def test_group_modify_remove_member(self):
with session.begin():
user = data_setup.create_user()
self.group.add_member(user)
session.flush()
self.assert_(user in self.group.users)
mail_capture_thread.start_capturing()
out = run_client([
'bkr', 'group-modify', '--remove-member', user.user_name,
self.group.group_name
],
config=self.client_config)
with session.begin():
session.refresh(self.group)
group = Group.by_name(self.group.group_name)
self.assert_(
user.user_name not in [u.user_name for u in group.users])
self.check_notification(user, group, action='Removed')
with session.begin():
session.refresh(self.group)
group = Group.by_name(self.group.group_name)
self.assertEquals(group.activity[-1].action, u'Removed')
self.assertEquals(group.activity[-1].field_name, u'User')
self.assertEquals(group.activity[-1].user.user_id,
self.user.user_id)
self.assertEquals(group.activity[-1].old_value, user.user_name)
self.assertEquals(group.activity[-1].new_value, None)
self.assertEquals(group.activity[-1].service, u'HTTP')
try:
out = run_client([
'bkr', 'group-modify', '--remove-member', 'idontexist',
self.group.group_name
],
config=self.client_config)
self.fail('Must fail or die')
except ClientError, e:
self.assert_('User idontexist does not exist' in e.stderr_output,
e.stderr_output)
def test_system_activity_shows_changes_for_disk(self):
with session.begin():
system = data_setup.create_system()
self.server.push(
system.fqdn, {
'Disk': {
'Disks': [{
'model': 'Virtio Block Device',
'phys_sector_size': 512,
'sector_size': 512,
'size': str(8589934592)
}]
}
})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].field_name, 'Disk')
def test_can_change_loan_when_system_has_loanee(self):
with session.begin():
user = data_setup.create_user()
user2 = data_setup.create_user()
self.system.user = user
self.system.loaned = user
b = self.browser
login(b)
self.go_to_loan_page()
self.change_loan(user2.user_name)
self.verify_loan_update(user2.user_name)
with session.begin():
session.refresh(self.system)
reserved_activity = self.system.activity[-1]
self.assertEqual(reserved_activity.action, 'Changed')
self.assertEqual(reserved_activity.field_name, 'Loaned To')
self.assertEqual(reserved_activity.old_value, user.user_name)
self.assertEqual(reserved_activity.new_value, user2.user_name)
self.assertEqual(reserved_activity.service, 'HTTP')
def test_device_saved_properly(self):
with session.begin():
system = data_setup.create_system()
self.server.push(system.fqdn, {'Devices': [{
'type': None, 'bus': u'pci', 'driver': u'noclass',
'description': u'Oh so very tacky',
'vendorID': '1234', 'deviceID': '5678',
'subsysVendorID': '6543', 'subsysDeviceID': '1478',
'fw_version': 'ABCD'
}]})
with session.begin():
session.refresh(system)
self.assertEquals(system.devices[0].bus, u'pci' )
self.assertEquals(system.devices[0].driver, u'noclass')
self.assertEquals(system.devices[0].description, u'Oh so very tacky')
self.assertEquals(system.devices[0].vendor_id, '1234')
self.assertEquals(system.devices[0].device_id, '5678')
self.assertEquals(system.devices[0].subsys_vendor_id, '6543')
self.assertEquals(system.devices[0].subsys_device_id, '1478')
self.assertEquals(system.devices[0].fw_version, 'ABCD')
def test_doubled_quotes(self):
with session.begin():
system = data_setup.create_system(fqdn=u'mymainframe.funtimes.invalid', arch=u's390x')
OSMajor.lazy_create(osmajor=u'RedHatEnterpriseLinux7')
b = self.browser
login(b)
b.get(get_server_base() + 'csv/csv_import')
b.find_element_by_name('csv_file').send_keys(
pkg_resources.resource_filename(self.__module__, 'bz802842.csv'))
b.find_element_by_name('csv_file').submit()
self.failUnless(is_text_present(self.browser, "No Errors"))
with session.begin():
session.refresh(system)
self.assertEquals(system.provisions[Arch.by_name(u's390x')]\
.provision_families[OSMajor.by_name(u'RedHatEnterpriseLinux7')]\
.kernel_options,
'rd.znet="qeth,0.0.8000,0.0.8001,0.0.8002,layer2=1,portname=lol,portno=0" '
'ip=1.2.3.4::1.2.3.4:255.255.248.0::eth0:none MTU=1500 nameserver=1.2.3.4 '
'DASD=20A1,21A1,22A1,23A1 MACADDR=02:DE:AD:BE:EF:16 '
'!LAYER2 !DNS !PORTNO !IPADDR !GATEWAY !HOSTNAME !NETMASK ')
def test_can_remove_tag_from_distro(self):
b = self.browser
login(b, data_setup.ADMIN_USER, data_setup.ADMIN_PASSWORD)
go_to_distro_view(b, self.distro)
delete_and_confirm(b, '//td[normalize-space(preceding-sibling::td[1]/text())="SAD"]')
self.assertEquals(b.find_element_by_class_name('flash').text,
'Removed Tag SAD')
b.find_element_by_xpath('//div[@class="tags"]//table[not('
'.//td[normalize-space(text())="SAD"])]')
with session.begin():
session.refresh(self.distro)
self.assert_(u'SAD' not in self.distro.tags)
with session.begin():
session.refresh(self.distro)
activity = self.distro.activity[0]
self.assertEquals(activity.field_name, u'Tag')
self.assertEquals(activity.service, u'WEBUI')
self.assertEquals(activity.action, u'Removed')
self.assertEquals(activity.old_value, u'SAD')
self.assertEquals(activity.new_value, None)
def test_group_modify_remove_multiple_members(self):
with session.begin():
user1 = data_setup.create_user()
user2 = data_setup.create_user()
self.group.add_member(user1)
self.group.add_member(user2)
session.flush()
self.assert_(user1 in self.group.users)
self.assert_(user2 in self.group.users)
out = run_client([
'bkr', 'group-modify', '--remove-member', user1.user_name,
'--remove-member', user2.user_name, self.group.group_name
],
config=self.client_config)
with session.begin():
session.refresh(self.group)
self.assertNotIn(user1, self.group.users)
self.assertNotIn(user2, self.group.users)
def test_set_plaintext_password(self):
b = self.browser
login(b, user=self.user.user_name, password='******')
self._make_and_go_to_owner_page(self.user, self.group)
e = b.find_element_by_xpath('//input[@id="Group_root_password"]')
e.clear()
e.send_keys(self.clear_password)
b.find_element_by_id('Group').submit()
self.assertEquals(b.find_element_by_class_name('flash').text, u'OK')
b.get(get_server_base() + 'groups/mine')
b.find_element_by_link_text(self.group.group_name).click()
clear_pass = b.find_element_by_xpath(
'//input[@id="Group_root_password"]').get_attribute('value')
self.assertEquals(clear_pass, self.clear_password)
# check if the change has been recorded in the acitivity table
with session.begin():
self.assertEquals(self.group.activity[-1].action, u'Changed')
self.assertEquals(self.group.activity[-1].field_name,
u'Root Password')
self.assertEquals(self.group.activity[-1].old_value, '*****')
self.assertEquals(self.group.activity[-1].new_value, '*****')
self.assertEquals(self.group.activity[-1].service, u'WEBUI')
# no change should be recorded if the same password is supplied
group_activities = len([
x for x in self.group.activity if x.field_name == 'Root Password'
])
self._make_and_go_to_owner_page(self.user, self.group)
e = b.find_element_by_xpath('//input[@id="Group_root_password"]')
e.clear()
e.send_keys(clear_pass)
b.find_element_by_id('Group').submit()
self.assertEquals(b.find_element_by_class_name('flash').text, u'OK')
session.refresh(self.group)
self.assertEquals(
group_activities,
len([
x for x in self.group.activity
if x.field_name == 'Root Password'
]))
def test_revert_notification_preferences(self):
with session.begin():
self.user.notify_job_completion = True
self.user.notify_broken_system = True
self.user.notify_group_membership = False
self.user.notify_reservesys = False
b = self.browser
pane = self.go_to_prefs_tab('Notifications')
checkbox_notify_job = pane.find_element_by_name(
'notify_job_completion')
self.assertTrue(checkbox_notify_job.is_selected())
checkbox_notify_job.click()
revert_btn = pane.find_element_by_xpath('.//button[normalize-space'
'(string(.))="Revert"]')
revert_btn.click()
with session.begin():
session.refresh(self.user)
self.assertEqual(self.user.notify_job_completion, True)
self.assertEqual(self.user.notify_broken_system, True)
self.assertEqual(self.user.notify_group_membership, False)
self.assertEqual(self.user.notify_reservesys, False)
def test_remove_group(self):
with session.begin():
group = data_setup.create_group()
self.system.groups.append(group)
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Groups')
b.find_element_by_xpath('//td[normalize-space(text())="%s"]' %
group.group_name)
delete_and_confirm(
b, '//tr[normalize-space(td[1]/text())="%s"]' % group.group_name)
self.assertEquals(
b.find_element_by_class_name('flash').text,
'%s Removed' % group.display_name)
b.find_element_by_xpath(
'//div[@id="groups" and not(.//td[normalize-space(text())="%s"])]'
% group.group_name)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def test_system_activity_shows_changes(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.extend([
Key_Value_String(Key.by_name(u'PCIID'), '1022:2000'),
Key_Value_String(Key.by_name(u'PCIID'), '80ee:beef'),
])
self.server.legacypush(system.fqdn,
{'PCIID': ['80ee:cafe', '80ee:beef']})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].field_name, u'Key/Value')
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].old_value, None)
self.assertEquals(system.activity[0].new_value, u'PCIID/80ee:cafe')
self.assertEquals(system.activity[1].field_name, u'Key/Value')
self.assertEquals(system.activity[1].service, u'XMLRPC')
self.assertEquals(system.activity[1].action, u'Removed')
self.assertEquals(system.activity[1].old_value, u'PCIID/1022:2000')
self.assertEquals(system.activity[1].new_value, None)
def test_existing_keys_are_untouched(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.extend([
Key_Value_String(Key.by_name(u'PCIID'),
'1022:2000'), # this one gets deleted
Key_Value_String(Key.by_name(u'HVM'),
'0'), # this one gets updated
Key_Value_String(Key.by_name(u'VENDOR'),
'Bob'), # this one should not be touched
])
self.server.legacypush(system.fqdn, {'PCIID': [], 'HVM': True})
with session.begin():
session.refresh(system)
self.assertEquals(len(system.key_values_string), 2,
system.key_values_string)
self.assertEquals(system.key_values_string[0].key.key_name,
u'VENDOR')
self.assertEquals(system.key_values_string[0].key_value, u'Bob')
self.assertEquals(system.key_values_string[1].key.key_name, u'HVM')
self.assertEquals(system.key_values_string[1].key_value, u'1')
def test_disks_are_updated(self):
with session.begin():
system = data_setup.create_system()
# We test with multiple identical disks, because that is very common in
# real systems and it tickles some corner cases on the server side.
testdict = dict(model='foo',
phys_sector_size=4096,
sector_size=4096,
size=str(500107837440))
self.server.push(system.fqdn,
dict(Disk=dict(Disks=[testdict, testdict])))
with session.begin():
session.refresh(system)
self.assertEquals(len(system.disks), 2)
self.assertEquals(system.disks[0].model, u'foo')
self.assertEquals(system.disks[0].size, 500107837440)
self.assertEquals(system.disks[0].sector_size, 4096)
self.assertEquals(system.disks[0].phys_sector_size, 4096)
self.assertEquals(system.disks[1].model, u'foo')
self.assertEquals(system.disks[1].size, 500107837440)
self.assertEquals(system.disks[1].sector_size, 4096)
self.assertEquals(system.disks[1].phys_sector_size, 4096)
# make sure we can update a system with existing disks
testdict['model'] = 'newer'
self.server.push(system.fqdn,
dict(Disk=dict(Disks=[testdict, testdict])))
with session.begin():
session.refresh(system)
self.assertEquals(len(system.disks), 2)
self.assertEquals(system.disks[0].model, u'newer')
self.assertEquals(system.disks[0].size, 500107837440)
self.assertEquals(system.disks[0].sector_size, 4096)
self.assertEquals(system.disks[0].phys_sector_size, 4096)
self.assertEquals(system.disks[1].model, u'newer')
self.assertEquals(system.disks[1].size, 500107837440)
self.assertEquals(system.disks[1].sector_size, 4096)
self.assertEquals(system.disks[1].phys_sector_size, 4096)
def test_system_secret_field(self):
login(self.browser)
self.import_csv((u'csv_type,fqdn,secret\n'
u'system,%s,True' % self.system.fqdn).encode('utf8'))
self.assertEquals(
self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text, 'No Errors')
with session.begin():
session.refresh(self.system.custom_access_policy)
self.assertFalse(
self.system.custom_access_policy.grants_everybody(
SystemPermission.view))
self.import_csv((u'csv_type,fqdn,secret\n'
u'system,%s,False' % self.system.fqdn).encode('utf8'))
self.assertEquals(
self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text, 'No Errors')
with session.begin():
session.refresh(self.system.custom_access_policy)
self.assertTrue(
self.system.custom_access_policy.grants_everybody(
SystemPermission.view))
def test_group_modify_grant_owner(self):
with session.begin():
user1 = data_setup.create_user()
user1.groups.append(self.group)
user2 = data_setup.create_user()
user2.groups.append(self.group)
user3 = data_setup.create_user()
out = run_client([
'bkr', 'group-modify', '--grant-owner', user1.user_name,
'--grant-owner', user2.user_name, self.group.group_name
],
config=self.client_config)
with session.begin():
session.refresh(self.group)
group = Group.by_name(self.group.group_name)
self.assert_(user1.user_id in [u.user_id for u in group.owners()])
self.assert_(user2.user_id in [u.user_id for u in group.owners()])
self.assertEquals(
Activity.query.filter_by(service=u'XMLRPC',
field_name=u'Owner',
action=u'Added',
new_value=user2.user_name).count(), 1)
group = Group.by_name(group.group_name)
self.assertEquals(group.activity[-1].action, u'Added')
self.assertEquals(group.activity[-1].field_name, u'Owner')
self.assertEquals(group.activity[-1].new_value, user2.user_name)
self.assertEquals(group.activity[-1].service, u'XMLRPC')
try:
out = run_client([
'bkr', 'group-modify', '--grant-owner', user3.user_name,
self.group.group_name
],
config=self.client_config)
self.fail('Must fail or die')
except ClientError, e:
self.assert_('User is not a group member' in e.stderr_output)
def test_remove_key_value(self):
with session.begin():
self.system.key_values_int.append(
Key_Value_Int(Key.by_name(u'NR_DISKS'), 100))
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Key/Values')
b.find_element_by_xpath(
'//td[normalize-space(preceding-sibling::td[1]/text())'
'="NR_DISKS" and '
'normalize-space(text())="100"]')
delete_and_confirm(
b, '//tr[normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"]')
self.assertEquals(
b.find_element_by_class_name('flash').text, 'removed NR_DISKS/100')
b.find_element_by_xpath('//div[@id="keys" and not(.//tr['
'normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"])]')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def test_reserve_system(self):
with session.begin():
user = data_setup.create_user(password=u'password')
system = data_setup.create_system(
owner=User.by_user_name(data_setup.ADMIN_USER),
status=u'Manual', shared=True)
self.assert_(system.user is None)
server = self.get_server()
server.auth.login_password(user.user_name, 'password')
server.systems.reserve(system.fqdn)
with session.begin():
session.refresh(system)
self.assertEqual(system.user, user)
self.assertEqual(system.reservations[0].type, u'manual')
self.assertEqual(system.reservations[0].user, user)
self.assert_(system.reservations[0].finish_time is None)
assert_durations_not_overlapping(system.reservations)
reserved_activity = system.activity[-1]
self.assertEqual(reserved_activity.action, 'Reserved')
self.assertEqual(reserved_activity.field_name, 'User')
self.assertEqual(reserved_activity.user, user)
self.assertEqual(reserved_activity.new_value, user.user_name)
self.assertEqual(reserved_activity.service, 'XMLRPC')
class UpdatePrefsTest(ClientTestCase):
@with_transaction
def setUp(self):
self.user1 = data_setup.create_user(password=u'asdf')
self.user2 = data_setup.create_user(password=u'qwerty')
self.client_config1 = create_client_config(
username=self.user1.user_name, password='******')
self.client_config2 = create_client_config(
username=self.user2.user_name, password='******')
def test_user_edit_email(self):
try:
run_client([
'bkr', 'update-prefs',
'--email=%s' % self.user1.email_address
],
config=self.client_config1)
self.fail('should raise')
except ClientError, e:
self.assertIn('is same as before', e.stderr_output)
run_client(
['bkr', 'update-prefs',
'--email=%s' % self.user2.email_address],
config=self.client_config1)
# This used to be forbidden, now it is allowed.
with session.begin():
session.refresh(self.user1)
self.assertEquals(self.user1.email_address,
self.user2.email_address)
run_client(['bkr', 'update-prefs', '[email protected]'],
config=self.client_config1)
with session.begin():
session.refresh(self.user1)
self.assertEquals(self.user1.email_address, "*****@*****.**")
def test_system_rename(self):
login(self.browser)
# attempt to rename existing system to an invalid FQDN should keep
# the system unmodified
with session.begin():
session.refresh(self.system)
orig_date_modified = self.system.date_modified
self.import_csv((u'csv_type,id,fqdn,location,arch\n'
u'system,%s,new--fqdn.name,%s,%s' %
(self.system.id, self.system.location,
self.system.arch[0])).encode('utf8'))
with session.begin():
session.refresh(self.system)
self.assertEquals(self.system.date_modified, orig_date_modified)
self.assertEquals(
self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text,
"Error importing line 2: "
"Invalid FQDN for system: new--fqdn.name")
# attempt to rename a non-existent system should fail
orig_date_modified = self.system.date_modified
non_existent_system_id = -1
self.import_csv((u'csv_type,id,fqdn,location,arch\n'
u'system,%s,new--fqdn.name,%s,%s' %
(non_existent_system_id, self.system.location,
self.system.arch[0])).encode('utf8'))
with session.begin():
session.refresh(self.system)
self.assertEquals(self.system.date_modified, orig_date_modified)
self.assertEquals(
self.browser.find_element_by_xpath(
'//table[@id="csv-import-log"]//td').text,
"Error importing line 2: "
"Non-existent system id")
# successfully rename existing system
orig_date_modified = self.system.date_modified
self.import_csv((u'csv_type,id,fqdn,location,arch\n'
u'system,%s,new.fqdn.name,Under my desk,ia64' %
self.system.id).encode('utf8'))
with session.begin():
session.refresh(self.system)
self.assertGreater(self.system.date_modified, orig_date_modified)
self.assertEquals(self.system.fqdn, 'new.fqdn.name')
def test_disk_is_updated(self):
with session.begin():
system = data_setup.create_system()
testdict = dict(model='foo',
phys_sector_size=4096,
sector_size=4096,
size=str(500107837440))
self.server.push(system.fqdn, dict(Disk=dict(Disks=[testdict])))
with session.begin():
session.refresh(system)
self.assertEquals(system.disks[0].model, testdict['model'])
self.assertEquals(system.disks[0].size, int(testdict['size']))
self.assertEquals(system.disks[0].sector_size,
testdict['sector_size'])
self.assertEquals(system.disks[0].phys_sector_size,
testdict['phys_sector_size'])
# make sure we can update a system with existing disks
testdict['model'] = 'newer'
self.server.push(system.fqdn, dict(Disk=dict(Disks=[testdict])))
with session.begin():
session.refresh(system)
self.assertEquals(system.disks[0].model, testdict['model'])
def test_admin_cannot_rename_protected_group(self):
# See https://bugzilla.redhat.com/show_bug.cgi?id=961206
protected_group_name = u'admin'
with session.begin():
group = Group.by_name(protected_group_name)
expected_display_name = group.display_name
# Run command as the default admin user
try:
out = run_client([
'bkr', 'group-modify', '--group-name', 'new_admin',
'--display-name', 'this is also unchanged',
protected_group_name
])
self.fail('Must fail or die')
except ClientError as e:
self.assert_('Cannot rename protected group' in e.stderr_output,
e.stderr_output)
# Check the whole request is ignored if the name change is rejected
with session.begin():
session.refresh(group)
self.assertEquals(group.group_name, protected_group_name)
self.assertEquals(group.display_name, expected_display_name)
# However, changing just the display name is fine
new_display_name = 'Tested admin group'
out = run_client([
'bkr', 'group-modify', '--display-name', new_display_name,
protected_group_name
])
with session.begin():
session.refresh(group)
self.assertEquals(group.group_name, protected_group_name)
self.assertEquals(group.display_name, new_display_name)
def test_reserve_via_external_service(self):
with session.begin():
service_group = data_setup.create_group(permissions=[u'proxy_auth'])
service_user = data_setup.create_user(password=u'password')
service_group.add_member(service_user)
user = data_setup.create_user(password=u'notused')
system = data_setup.create_system(
owner=User.by_user_name(data_setup.ADMIN_USER),
status=u'Manual', shared=True)
self.assert_(system.user is None)
server = self.get_server()
server.auth.login_password(service_user.user_name, 'password',
user.user_name)
server.systems.reserve(system.fqdn)
with session.begin():
session.refresh(system)
self.assertEqual(system.user, user)
self.assertEqual(system.reservations[0].type, u'manual')
self.assertEqual(system.reservations[0].user, user)
self.assert_(system.reservations[0].finish_time is None)
assert_durations_not_overlapping(system.reservations)
reserved_activity = system.activity[0]
self.assertEqual(reserved_activity.action, 'Reserved')
self.assertEqual(reserved_activity.service, service_user.user_name)
