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(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_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_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_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_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_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_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_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 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_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_add_group(self):
        with session.begin():
            group = data_setup.create_group()
            user_password = "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_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_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_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_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_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('[email protected]')
     tab.find_element_by_class_name('cc-add').submit()
     tab.find_element_by_xpath('.//li[contains(text(), "[email protected]")]')
     tab.find_element_by_name('cc').send_keys('[email protected]')
     tab.find_element_by_class_name('cc-add').submit()
     tab.find_element_by_xpath('.//li[contains(text(), "[email protected]")]')
     tab.find_element_by_xpath('.//li[contains(text(), "[email protected]")]')
     with session.begin():
         session.refresh(self.system)
         self.assertEquals(set(self.system.cc),
                 set([u'[email protected]', u'[email protected]']))
         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'[email protected]')
         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'[email protected]')

 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_add_group(self):
        with session.begin():
            group = data_setup.create_group()
            user_password = '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])