コード例 #1
0
 def test_systems_by_cpu_type(self):
     vendor = u'AcmeCorp'
     common_cpu_family = 1
     common_cpu_stepping = 2
     rare_cpu_family = 3
     rare_cpu_stepping = 4
     for _ in range(2):
         data_setup.create_system().cpu = Cpu(vendor=vendor, model=1,
                 family=rare_cpu_family, stepping=rare_cpu_stepping)
     for _ in range(20):
         data_setup.create_system().cpu = Cpu(vendor=vendor, model=1,
                 family=common_cpu_family, stepping=common_cpu_stepping)
     data_setup.create_system(status=SystemStatus.removed).cpu = \
         Cpu(vendor=vendor)
     data_setup.create_system().cpu = None # un-inventoried
     session.flush()
     rows = list(self.execute_reporting_query('system-count-by-cpu'))
     # un-inventoried systems should show up at the top
     self.assertEquals(rows[0].cpu_vendor, None)
     self.assertEquals(rows[0].cpu_model, None)
     self.assertEquals(rows[0].cpu_family, None)
     self.assertEquals(rows[0].cpu_stepping, None)
     self.assert_(rows[0].system_count >= 1, rows[0])
     # check for fake CPUs created above
     vendor_rows = [row for row in rows if row.cpu_vendor == vendor]
     self.assertEquals(len(vendor_rows), 2, vendor_rows)
     self.assertEquals(vendor_rows[0].cpu_model, 1)
     self.assertEquals(vendor_rows[0].cpu_family, common_cpu_family)
     self.assertEquals(vendor_rows[0].cpu_stepping, common_cpu_stepping)
     self.assertEquals(vendor_rows[0].system_count, 20)
     self.assertEquals(vendor_rows[1].cpu_model, 1)
     self.assertEquals(vendor_rows[1].cpu_family, rare_cpu_family)
     self.assertEquals(vendor_rows[1].cpu_stepping, rare_cpu_stepping)
     self.assertEquals(vendor_rows[1].system_count, 2)
コード例 #2
0
    def setUp(self):
        self.selenium = self.get_selenium()
        self.password = '******'

        # create users
        self.user_1 = data_setup.create_user(password=self.password)
        self.user_2 = data_setup.create_user(password=self.password)
        self.user_3 = data_setup.create_user(password=self.password)

        # create admin users
        self.admin_1 = data_setup.create_user(password=self.password)
        self.admin_1.groups.append(Group.by_name(u'admin'))
        self.admin_2 = data_setup.create_user(password=self.password)
        self.admin_2.groups.append(Group.by_name(u'admin'))

        # create systems
        self.system_1 = data_setup.create_system(shared=True)
        self.system_2 = data_setup.create_system(shared=True)
        self.system_3 = data_setup.create_system(shared=False,
                                                 owner=self.user_3)

        # create group and add users/systems to it
        self.group_1 = data_setup.create_group()
        self.user_3.groups.append(self.group_1)
        self.admin_2.groups.append(self.group_1)
        self.system_2.groups.append(self.group_1)

        lc = data_setup.create_labcontroller()
        self.system_1.lab_controller = lc
        self.system_2.lab_controller = lc
        self.system_3.lab_controller = lc

        self.selenium.start()
コード例 #3
0
 def test_serial_number_column(self):
     with session.begin():
         system_with_serial = data_setup.create_system()
         system_with_serial.serial = u'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
         system_without_serial = data_setup.create_system()
         system_without_serial.serial = None
     b = self.browser
     b.get(get_server_base())
     b.find_element_by_link_text('Show Search Options').click()
     wait_for_animation(b, '#searchform')
     Select(b.find_element_by_name('systemsearch-0.table'))\
         .select_by_visible_text('System/SerialNumber')
     Select(b.find_element_by_name('systemsearch-0.operation'))\
         .select_by_visible_text('is')
     # This also tests that whitespace does not foil us
     b.find_element_by_name('systemsearch-0.value').send_keys(
             ' %s ' % system_with_serial.serial)
     b.find_element_by_link_text('Toggle Result Columns').click()
     wait_for_animation(b, '#selectablecolumns')
     b.find_element_by_link_text('Select None').click()
     b.find_element_by_name('systemsearch_column_System/Name').click()
     b.find_element_by_name('systemsearch_column_System/SerialNumber').click()
     b.find_element_by_id('searchform').submit()
     check_system_search_results(b, present=[system_with_serial],
             absent=[system_without_serial])
     b.find_element_by_xpath('//table[@id="widget"]'
             '//td[2][normalize-space(text())="%s"]' % system_with_serial.serial)
コード例 #4
0
    def setUpClass(cls):

        # date times
        cls.today = datetime.date.today()
        cls.time_now = datetime.datetime.combine(cls.today, datetime.time(0, 0))
        cls.time_delta1 = datetime.datetime.combine(cls.today, datetime.time(0, 30))
        cls.time_tomorrow = cls.time_now + datetime.timedelta(days=1)
        cls.time_yesterday = cls.time_now - datetime.timedelta(days=1)
        # today date
        cls.date_yesterday = cls.time_yesterday.date().isoformat()
        cls.date_today = cls.time_now.date().isoformat()
        cls.date_tomorrow = cls.time_tomorrow.date().isoformat()

        with session.begin():
            cls.user = data_setup.create_user(password=u'pass')
            cls.not_inv = data_setup.create_system(loaned=cls.user)

            cls.inv1 = data_setup.create_system(loaned=cls.user)
            cls.inv1.date_lastcheckin = cls.time_now

            cls.inv2 = data_setup.create_system(loaned=cls.user)
            cls.inv2.date_lastcheckin = cls.time_delta1

            cls.inv3 = data_setup.create_system(loaned=cls.user)
            cls.inv3.date_lastcheckin = cls.time_tomorrow

            cls.inv4 = data_setup.create_system(loaned=cls.user)
            cls.inv4.date_lastcheckin = cls.time_yesterday
コード例 #5
0
 def test_machine_hours(self):
     user = data_setup.create_user()
     # recipes/reservations straddle the boundary of the reporting period
     # to test we clamp them properly
     data_setup.create_completed_job(owner=user,
             distro_tree=data_setup.create_distro_tree(arch=u'ia64'),
             start_time=datetime.datetime(2012, 9, 30, 23, 0, 0),
             finish_time=datetime.datetime(2012, 10, 1, 1, 0, 0))
     data_setup.create_manual_reservation(user=user,
             system=data_setup.create_system(arch=u'ia64'),
             start=datetime.datetime(2012, 10, 31, 22, 30, 0),
             finish=datetime.datetime(2012, 11, 1, 1, 0, 0))
     data_setup.create_completed_job(owner=user,
             distro_tree=data_setup.create_distro_tree(arch=u'ppc64'),
             start_time=datetime.datetime(2012, 9, 30, 20, 0, 0),
             finish_time=datetime.datetime(2012, 10, 1, 2, 0, 0))
     data_setup.create_manual_reservation(user=user,
             system=data_setup.create_system(arch=u'ppc64'),
             start=datetime.datetime(2012, 10, 31, 23, 0, 0),
             finish=datetime.datetime(2012, 11, 1, 10, 0, 0))
     session.flush()
     rows = self.execute_reporting_query('machine-hours-by-user-arch')
     user_rows = [row for row in rows if row.username == user.user_name]
     self.assertEquals(len(user_rows), 2, user_rows)
     self.assertEquals(user_rows[0].arch, 'ia64')
     self.assertEquals(user_rows[0].machine_hours, Decimal('2.5'))
     self.assertEquals(user_rows[1].arch, 'ppc64')
     self.assertEquals(user_rows[1].machine_hours, Decimal('3.0'))
コード例 #6
0
ファイル: test_users.py プロジェクト: beaker-project/beaker
 def test_user_resource_counts_are_accurate_when_removing(self):
     with session.begin():
         user = data_setup.create_user()
         job = data_setup.create_job(owner=user)
         data_setup.mark_job_running(job)
         owned_system = data_setup.create_system(owner=user)
         loaned_system = data_setup.create_system()
         loaned_system.loaned = user
         owned_pool = data_setup.create_system_pool(owning_user=user)
         group = data_setup.create_group(owner=user)
     s = requests.Session()
     requests_login(s)
     response = s.get(get_server_base() + 'users/%s' % user.user_name,
             headers={'Accept': 'application/json'})
     response.raise_for_status()
     self.assertEquals(response.json()['job_count'], 1)
     self.assertEquals(response.json()['reservation_count'], 1)
     self.assertEquals(response.json()['loan_count'], 1)
     self.assertEquals(response.json()['owned_system_count'], 1)
     self.assertEquals(response.json()['owned_pool_count'], 1)
     response = patch_json(get_server_base() + 'users/%s' % user.user_name,
             data={'removed': 'now'}, session=s)
     response.raise_for_status()
     # The bug was that the counts in the PATCH response would still show 
     # their old values, because the queries for producing the counts were 
     # being run before all the removals were flushed to the database.
     # Note that job_count stays as 1, because the job has been cancelled 
     # but it will still be running until the next iteration of beakerd's 
     # update_dirty_jobs.
     self.assertEquals(response.json()['job_count'], 1)
     self.assertEquals(response.json()['reservation_count'], 0)
     self.assertEquals(response.json()['loan_count'], 0)
     self.assertEquals(response.json()['owned_system_count'], 0)
     self.assertEquals(response.json()['owned_pool_count'], 0)
コード例 #7
0
    def test_group(self):
        pool_a = data_setup.create_system_pool()
        pool_b = data_setup.create_system_pool()
        system_0 = data_setup.create_system()
        system_a = data_setup.create_system()
        system_a.pools.append(pool_a)
        system_ab = data_setup.create_system()
        system_ab.pools.append(pool_a)
        system_ab.pools.append(pool_b)
        system_b = data_setup.create_system()
        system_b.pools.append(pool_b)
        self.check_filter("""
            <hostRequires>
                <and>
                    <group op="=" value="%s" />
                </and>
            </hostRequires>
            """ % pool_a.name,
            present=[system_a, system_ab],
            absent=[system_b, system_0])
        self.check_filter("""
            <hostRequires>
                <and>
                    <group op="!=" value="%s" />
                </and>
            </hostRequires>
            """ % pool_a.name,
            present=[system_b, system_0],
            absent=[system_a, system_ab])
        # https://bugzilla.redhat.com/show_bug.cgi?id=601952
        self.check_filter("""
            <hostRequires>
                <and>
                    <group op="==" value="" />
                </and>
            </hostRequires>
            """,
            present=[system_0],
            absent=[system_a, system_ab, system_b])
        self.check_filter("""
            <hostRequires>
                <and>
                    <group op="!=" value="" />
                </and>
            </hostRequires>
            """,
            present=[system_a, system_ab, system_b],
            absent=[system_0])

        # https://bugzilla.redhat.com/show_bug.cgi?id=1226076
        self.check_filter("""
            <hostRequires>
                <or>
                    <group op="=" value="%s" />
                    <group op="=" value="%s" />
                </or>
            </hostRequires>
            """ % (pool_a.name, pool_b.name),
            present=[system_a, system_ab, system_b],
            absent=[system_0])
コード例 #8
0
ファイル: test_usage_reminder.py プロジェクト: omps/beaker
 def test_open_in_demand_systems(self):
     with session.begin():
         # system with waiting recipes
         system_with_waiting_recipes = data_setup.create_system()
         data_setup.create_manual_reservation(system_with_waiting_recipes,
                                              start=datetime.utcnow() - timedelta(days=self.reservation_length),
                                              user=self.user)
         recipe = data_setup.create_recipe()
         recipe.systems[:] = [system_with_waiting_recipes]
         job = data_setup.create_job_for_recipes([recipe])
         data_setup.mark_job_queued(job)
         job.recipesets[0].queue_time = datetime.utcnow() - timedelta(hours=self.waiting_recipe_age)
         # Create another system with waiting recipes and delete the job
         recipe_in_deleted_job = data_setup.create_recipe()
         recipe_in_deleted_job.systems[:] = [system_with_waiting_recipes]
         deleted_job = data_setup.create_job_for_recipes([recipe_in_deleted_job])
         data_setup.mark_job_queued(deleted_job)
         deleted_job.recipesets[0].queue_time = datetime.utcnow() - timedelta(hours=self.waiting_recipe_age)
         deleted_job.delete()
         # system with no waiting recipes
         system_without_waiting_recipes = data_setup.create_system()
         data_setup.create_manual_reservation(system_without_waiting_recipes,
                                              start=datetime.utcnow() - timedelta(days=self.reservation_length),
                                              user=self.user)
     beaker_usage = BeakerUsage(self.user, self.reservation_expiry, self.reservation_length,
                            self.waiting_recipe_age, self.delayed_job_age)
     open_in_demand_systems = beaker_usage.open_in_demand_systems()
     self.assertEqual(len(open_in_demand_systems), 1)
     self.assertEqual(open_in_demand_systems[0][1], 1)
     self.assertEqual(open_in_demand_systems[0][2], system_with_waiting_recipes.fqdn)
コード例 #9
0
    def test_modify_attributes_policy(self):
        with session.begin():
            system1 = data_setup.create_system(shared=False)
            system2 = data_setup.create_system(shared=False)
            new_owner = data_setup.create_user()
            perm = SystemPermission.reserve
            user1 = data_setup.create_user()
            system1.custom_access_policy.add_rule(perm, user=user1)
            system2.custom_access_policy.add_rule(perm, user=user1)
            pool = data_setup.create_system_pool(systems=[system1, system2])
            user2 = data_setup.create_user()
            pool.access_policy.add_rule(perm, user=user2)

        run_client(['bkr', 'system-modify',
                    '--owner', new_owner.user_name,
                    '--condition', 'Manual',
                    '--pool-policy', pool.name,
                    system1.fqdn, system2.fqdn])
        with session.begin():
            session.expire_all()
            for s in [system1, system2]:
                self.assertEquals(s.owner.user_name, new_owner.user_name)
                self.assertEquals(s.status, SystemStatus.manual)
                self.assertFalse(s.active_access_policy.grants(user1, perm))
                self.assertTrue(s.active_access_policy.grants(user2, perm))
コード例 #10
0
 def test_peer_roles(self):
     with session.begin():
         dt = data_setup.create_distro_tree()
         lc = data_setup.create_labcontroller()
         systems = [
             data_setup.create_system(fqdn=u'server.peer-roles.invalid', lab_controller=lc),
             data_setup.create_system(fqdn=u'clientone.peer-roles.invalid', lab_controller=lc),
             data_setup.create_system(fqdn=u'clienttwo.peer-roles.invalid', lab_controller=lc),
         ]
         job = data_setup.create_job_for_recipes([
             data_setup.create_recipe(distro_tree=dt, role=u'SERVERS'),
             data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
             data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
         ])
         job.recipesets[0].recipes[0].tasks[0].role = None
         # Normally you wouldn't use the same role name with different 
         # meaning at the task level, because that would just get 
         # confusing... but it is possible
         job.recipesets[0].recipes[1].tasks[0].role = u'SERVERS'
         job.recipesets[0].recipes[2].tasks[0].role = u'CLIENTTWO'
         for i in range(3):
             data_setup.mark_recipe_running(job.recipesets[0].recipes[i], system=systems[i])
     self.server.auth.login_password(self.lc.user.user_name, u'logmein')
     expected = {
         'SERVERS': ['server.peer-roles.invalid', 'clientone.peer-roles.invalid'],
         'CLIENTS': ['clientone.peer-roles.invalid', 'clienttwo.peer-roles.invalid'],
         'None': ['server.peer-roles.invalid'],
         'CLIENTTWO': ['clienttwo.peer-roles.invalid'],
     }
     for i in range(3):
         self.assertEquals(self.server.recipes.tasks.peer_roles(
                 job.recipesets[0].recipes[i].tasks[0].id),
                 expected)
コード例 #11
0
ファイル: test_nag_mail.py プロジェクト: sibiaoluo/beaker
    def setupClass(cls):
        cls.two_days_ago = datetime.datetime.utcnow() - datetime.timedelta(days=2)
        cls.three_days_ago = datetime.datetime.utcnow() - datetime.timedelta(days=3)

        cls.just_now = datetime.datetime.utcnow()

        cls.user_1 = data_setup.create_user()
        cls.user_2 = data_setup.create_user()
        cls.system_1 = data_setup.create_system(owner=cls.user_1, shared=True)
        cls.system_2 = data_setup.create_system(owner=cls.user_1, shared=True)
        cls.system_3 = data_setup.create_system(owner=cls.user_2, shared=True)

        cls.subject_header = '[Beaker Reminder]: System'

        #Shouldn't send
        #This tests that mail is not sent if user == owner
        cls.system_1.reserve(service=u'testdata', user=cls.user_1)
        cls.system_1.reservations[-1].start_time = cls.two_days_ago

        #Shouldn't send
        #This tests that threshold value is honoured
        cls.system_2.reserve(service=u'testdata', user=cls.user_2)
        cls.system_2.reservations[-1].start_time = cls.just_now

        #Should send
        #This tests that with owner != user and taken > threshold, should send nag
        cls.system_3.reserve(service=u'testdata', user=cls.user_1)
        cls.system_3.reservations[-1].start_time = cls.three_days_ago
コード例 #12
0
ファイル: test_create_kickstart.py プロジェクト: omps/beaker
    def test_distro_and_system_overrides_recipe(self):

        with session.begin():
            lc = data_setup.create_labcontroller()
            i386_distro = self._create_i386_distro(lc)
            system1 = data_setup.create_system(lab_controller=lc, arch=u'x86_64')
            system2 = data_setup.create_system(lab_controller=lc, arch=u'i386')
            system2.provisions[system2.arch[0]] = Provision(arch=system2.arch[0],
                kernel_options_post='usshopper')
        recipe = self._create_recipe(system1)

        # recipe uses system1 + x86_64 distro. We pass in system2 and i386
        # distro, so we should pick up the provision options of system2 + i386
        distro_tree_id = i386_distro.trees[0].id
        kickstart = self._run_create_kickstart(['--recipe-id', str(recipe.id),
                                                '--system', system2.fqdn,
                                                '--distro-tree-id', str(distro_tree_id),])

        # Make sure we are using the tree from --distro-tree-id
        self.assertIn('url=http://lab.test-kickstart.example.com/distros/'
            'RHEL-6.3/Workstation/i386/os/', kickstart)
        self.assertIn('usshopper', kickstart)
        # Make sure we are using system2
        self.assertIn(system2.fqdn, kickstart)
        self.assertNotIn(system1.fqdn, kickstart)
コード例 #13
0
    def test_list_systems_lc_disabled(self):
        with session.begin():
            lc1 = data_setup.create_labcontroller()
            lc2 = data_setup.create_labcontroller()
            system1 = data_setup.create_system(fqdn=data_setup.unique_name(u'aaaa%s.testdata'))
            system1.lab_controller = lc1
            system2 = data_setup.create_system(fqdn=data_setup.unique_name(u'aaaa%s.testdata'))
            system2.lab_controller = lc2

            # set lc2 to disabled
            lc2.disabled = True

        out = run_client(['bkr', 'system-list'])
        systems = out.splitlines()
        self.assertIn(system1.fqdn, systems)
        self.assertIn(system2.fqdn, systems)

        out = run_client(['bkr', 'system-list', '--free'])
        systems = out.splitlines()
        self.assertIn(system1.fqdn, systems)
        self.assertNotIn(system2.fqdn, systems)

        out = run_client(['bkr', 'system-list', '--available'])
        systems = out.splitlines()
        self.assertIn(system1.fqdn, systems)
        self.assertIn(system2.fqdn, systems)
コード例 #14
0
 def test_can_reserve_manual_system(self):
     with session.begin():
         broken_system = data_setup.create_system(
             arch=u"i386", shared=True, status=SystemStatus.broken, lab_controller=self.lc
         )
         manual_system = data_setup.create_system(
             arch=u"i386", shared=True, status=SystemStatus.manual, lab_controller=self.lc
         )
     b = self.browser
     login(b)
     # broken system should not be present
     go_to_reserve_systems(b, distro_tree=self.distro_tree_i386)
     search_for_system(b, broken_system)
     check_system_search_results(b, absent=[broken_system])
     # provision manual system
     go_to_reserve_systems(b, distro_tree=self.distro_tree_i386)
     search_for_system(b, manual_system)
     row = b.find_element_by_xpath('//tr[normalize-space(string(td))="%s"]' % manual_system.fqdn)
     row.find_element_by_link_text("Reserve Now").click()
     b.find_element_by_xpath('//button[normalize-space(text())="Submit job"]').click()
     # should end up on the job page
     job_id = b.find_element_by_xpath('//td[preceding-sibling::th/text()="Job ID"]/a').text
     with session.begin():
         job = TaskBase.get_by_t_id(job_id)
         cloned_job_xml = job.to_xml(clone=True).toxml()  # cloning re-parses hostRequires
         self.assertIn(u'<hostRequires force="%s"/>' % manual_system.fqdn, cloned_job_xml)
コード例 #15
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_or_lab_controller(self):
     lc1 = data_setup.create_labcontroller(fqdn=u'lab1')
     lc2 = data_setup.create_labcontroller(fqdn=u'lab2')
     lc3 = data_setup.create_labcontroller(fqdn=u'lab3')
     included = data_setup.create_system()
     included.lab_controller = lc1
     excluded = data_setup.create_system()
     excluded.lab_controller = lc3
     self.check_filter("""
            <hostRequires>
             <or>
              <hostlabcontroller op="=" value="lab1"/>
              <hostlabcontroller op="=" value="lab2"/>
             </or>
            </hostRequires>
         """,
         present=[included], absent=[excluded])
     self.check_filter("""
            <hostRequires>
             <or>
              <labcontroller op="=" value="lab1"/>
              <labcontroller op="=" value="lab2"/>
             </or>
            </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #16
0
 def test_group_column(self):
     with session.begin():
         group = data_setup.create_group()
         system_with_group = data_setup.create_system()
         system_with_group.groups.append(group)
         system_without_group = data_setup.create_system()
     b = self.browser
     b.get(get_server_base())
     b.find_element_by_link_text('Show Search Options').click()
     wait_for_animation(b, '#searchform')
     Select(b.find_element_by_name('systemsearch-0.table'))\
         .select_by_visible_text('System/Group')
     Select(b.find_element_by_name('systemsearch-0.operation'))\
         .select_by_visible_text('is')
     b.find_element_by_name('systemsearch-0.value').send_keys(group.group_name)
     b.find_element_by_link_text('Toggle Result Columns').click()
     wait_for_animation(b, '#selectablecolumns')
     b.find_element_by_link_text('Select None').click()
     b.find_element_by_name('systemsearch_column_System/Name').click()
     b.find_element_by_name('systemsearch_column_System/Group').click()
     b.find_element_by_id('searchform').submit()
     check_system_search_results(b, present=[system_with_group],
             absent=[system_without_group])
     b.find_element_by_xpath('//table[@id="widget"]'
             '//td[2][normalize-space(text())="%s"]' % group.group_name)
コード例 #17
0
    def test_filtering_by_diskspace(self):
        one_disk = data_setup.create_system()
        one_disk.disks[:] = [Disk(size=8000000000, sector_size=512, phys_sector_size=512)]
        two_disks = data_setup.create_system()
        two_disks.disks[:] = [Disk(size=500000000000, sector_size=512, phys_sector_size=512),
                              Disk(size=8000000000, sector_size=4096, phys_sector_size=4096)]
        self.check_filter("""
            <hostRequires>
                <diskspace op="&gt;" value="500" units="GB"/>
            </hostRequires>
            """,
            present=[two_disks], absent=[one_disk])

        self.check_filter("""
            <hostRequires>
                <diskspace op="&lt;" value="50" units="GB"/>
            </hostRequires>
            """,
            present=[one_disk], absent=[two_disks])

        self.check_filter("""
            <hostRequires>
                <diskspace op="==" value="508" units="GB"/>
            </hostRequires>
            """,
            present=[two_disks], absent=[one_disk])
コード例 #18
0
 def test_role_fqdns_not_duplicated(self):
     with session.begin():
         dt = data_setup.create_distro_tree()
         lc = data_setup.create_labcontroller()
         systems = [
             data_setup.create_system(fqdn=u'server.bz951283', lab_controller=lc),
             data_setup.create_system(fqdn=u'client.bz951283', lab_controller=lc),
         ]
         job = data_setup.create_job_for_recipes([
             data_setup.create_recipe(distro_tree=dt, role=u'SERVERS'),
             data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
         ])
         # same roles on the tasks as on the recipes
         job.recipesets[0].recipes[0].tasks[0].role = u'SERVERS'
         job.recipesets[0].recipes[1].tasks[0].role = u'CLIENTS'
         for i in range(2):
             data_setup.mark_recipe_running(job.recipesets[0].recipes[i], system=systems[i])
     self.server.auth.login_password(self.lc.user.user_name, u'logmein')
     expected = {
         'SERVERS': ['server.bz951283'],
         'CLIENTS': ['client.bz951283'],
     }
     for i in range(2):
         self.assertEquals(self.server.recipes.tasks.peer_roles(
                 job.recipesets[0].recipes[i].tasks[0].id),
                 expected)
コード例 #19
0
    def test_modify_active_access_policy(self):
        with session.begin():
            user1 = data_setup.create_user()
            perm = SystemPermission.reserve
            system1 = data_setup.create_system(shared=False)
            system2 = data_setup.create_system(shared=False)
            system1.custom_access_policy.add_rule(perm, user=user1)
            system2.custom_access_policy.add_rule(perm, user=user1)

            pool = data_setup.create_system_pool(systems=[system1, system2])
            user2 = data_setup.create_user()
            pool.access_policy.add_rule(perm, user=user2)

        # use pool policy
        run_client(['bkr', 'system-modify',
                    '--pool-policy', pool.name,
                    system1.fqdn, system2.fqdn])
        with session.begin():
            session.expire_all()
            for s in [system1, system2]:
                self.assertFalse(s.active_access_policy.grants(user1, perm))
                self.assertTrue(s.active_access_policy.grants(user2, perm))
                self.assertEquals(s.activity[-1].field_name, u'Active Access Policy')
                self.assertEquals(s.activity[-1].action, u'Changed')
                self.assertEquals(s.activity[-1].old_value, 'Custom Access Policy')
                self.assertEquals(s.activity[-1].new_value,'Pool policy: %s' % pool.name)

        # system not in a pool
        try:
            run_client(['bkr', 'system-modify',
                        '--pool-policy', data_setup.create_system_pool().name,
                        system1.fqdn])
        except ClientError as e:
            self.assertIn('To use a pool policy, the system must be in the pool first',
                          e.stderr_output)

        # Revert to custom policy
        run_client(['bkr', 'system-modify',
                    '--use-custom-policy',
                    system1.fqdn, system2.fqdn])

        with session.begin():
            session.expire_all()
            for s in [system1, system2]:
                self.assertTrue(s.active_access_policy.grants(user1, perm))
                self.assertFalse(s.active_access_policy.grants(user2, perm))

        # insufficient permission to change active policy
        with session.begin():
            user1 = data_setup.create_user(password='******')
        try:
            run_client(['bkr', 'system-modify',
                        '--use-custom-policy',
                        '--user', user1.user_name,
                        '--password', 'abc',
                        system1.fqdn])
            self.fail('Must raise')
        except ClientError as e:
            self.assertIn('Cannot edit system access policy',
                          e.stderr_output)
コード例 #20
0
    def setUpClass(cls):
        cls.browser = cls.get_browser()
        login(cls.browser)
        cls.system_one_details = { 'fqdn' : u'a1',
                                    'type' : u'Machine',
                                    'arch' : u'i386',
                                    'status' : u'Automated',
                                    'owner' : data_setup.create_user(),}
        cls.system_one = data_setup.create_system(**cls.system_one_details)
        cls.system_one.loaned = data_setup.create_user()
        cls.system_one.numa = Numa(nodes=2)
        cls.system_one.key_values_string.append(Key_Value_String(
            Key.by_name(u'CPUMODEL'), 'foocodename'))
        cls.system_one.key_values_string.append(Key_Value_String(
            Key.by_name(u'HVM'), '1'))
        cls.system_one.cpu = Cpu(flags=['flag1', 'flag2'])

        cls.system_one.key_values_int.append(Key_Value_Int(
            Key.by_name(u'DISKSPACE'), '1024'))
        cls.system_one.key_values_int.append(Key_Value_Int(
            Key.by_name(u'MEMORY'), '4096'))

        cls.system_two_details = { 'fqdn' : u'a2',
                                    'type' : u'Prototype',
                                    'arch' : u'x86_64',
                                    'status' : u'Manual',
                                    'owner' : data_setup.create_user(),}
        cls.system_two = data_setup.create_system(**cls.system_two_details)
        cls.system_two.key_values_int.append(Key_Value_Int(
            Key.by_name(u'DISKSPACE'), '900'))
        cls.system_two.key_values_string.append(Key_Value_String(
            Key.by_name(u'HVM'), '1'))

        device_class = DeviceClass.lazy_create(device_class='class_type')
        device1 = Device.lazy_create(vendor_id = '0000',
                                      device_id = '0000',
                                      subsys_vendor_id = '2223',
                                      subsys_device_id = '2224',
                                      bus = '0000',
                                      driver = '0000',
                                      device_class_id = device_class.id,
                                      description = 'blah')
        cls.system_two.devices.append(device1)
        cls.system_three_details = { 'fqdn' : u'a3',
                                    'type' : u'Laptop',
                                    'arch' : u'ia64',
                                    'status' : u'Removed',
                                    'owner' : data_setup.create_user(),}
        cls.system_three = data_setup.create_system(**cls.system_three_details)
        cls.system_three.numa = Numa(nodes=1)
        device2 = Device.lazy_create(vendor_id = '0000',
                                      device_id = '0000',
                                      subsys_vendor_id = '1111',
                                      subsys_device_id = '1112',
                                      bus = '0000',
                                      driver = '0000',
                                      device_class_id = device_class.id,
                                      description = 'blah')
        cls.system_three.devices.append(device2)
コード例 #21
0
 def setUp(self):
     with session.begin():
         self.user = data_setup.create_user(password=u'hypervisin')
         self.kvm = data_setup.create_system(loaned=self.user, hypervisor=u'KVM')
         self.xen = data_setup.create_system(loaned=self.user, hypervisor=u'Xen')
         self.phys = data_setup.create_system(loaned=self.user, hypervisor=None)
     self.browser = self.get_browser()
     login(self.browser, user=self.user.user_name, password=u'hypervisin')
コード例 #22
0
 def test_old_command_list_systems_still_works(self):
     with session.begin():
         data_setup.create_system() # so that we have at least one
         system1 = data_setup.create_system(status=SystemStatus.removed)
     out = run_client(['bkr', 'list-systems'])
     self.assertNotIn(system1.fqdn, out.splitlines())
     self.assertEqual(len(out.splitlines()),
                      System.query.filter(System.status!=SystemStatus.removed).count())
コード例 #23
0
 def test_list_removed_systems(self):
     with session.begin():
         system1 = data_setup.create_system() 
         system2 = data_setup.create_system(status=SystemStatus.removed)
     out = run_client(['bkr', 'system-list', '--removed'])
     self.assertIn(system2.fqdn, out.splitlines())
     self.assertEqual(len(out.splitlines()),
                      System.query.filter(System.status==SystemStatus.removed).count())
コード例 #24
0
ファイル: test_users.py プロジェクト: beaker-project/beaker
 def test_remove_account(self):
     with session.begin():
         user = data_setup.create_user()
         job = data_setup.create_job(owner=user)
         data_setup.mark_job_running(job)
         owned_system = data_setup.create_system(owner=user)
         loaned_system = data_setup.create_system()
         loaned_system.loaned = user
         reserved_system = data_setup.create_system(status=SystemStatus.manual)
         reserved_system.reserve_manually(service=u'testdata', user=user)
         reserved_system.custom_access_policy.add_rule(
                 SystemPermission.reserve, user=user)
         owned_pool = data_setup.create_system_pool(owning_user=user)
         group = data_setup.create_group(owner=user)
     s = requests.Session()
     requests_login(s)
     response = patch_json(get_server_base() + 'users/%s' % user.user_name,
             data={'removed': 'now'}, session=s)
     response.raise_for_status()
     with session.begin():
         session.expire_all()
         self.assertIsNotNone(user.removed)
         # running jobs should be cancelled
         job.update_status()
         self.assertEquals(job.status, TaskStatus.cancelled)
         self.assertIn('User %s removed' % user.user_name,
                       job.recipesets[0].recipes[0].tasks[0].results[0].log)
         # reservations should be released
         self.assertIsNone(reserved_system.user)
         # loans should be returned
         self.assertIsNone(loaned_system.loaned)
         # access policy rules should be removed
         self.assertEqual([],
                 [rule for rule in reserved_system.custom_access_policy.rules
                  if rule.user == user])
         self.assertEqual(reserved_system.activity[0].field_name, u'Access Policy Rule')
         self.assertEqual(reserved_system.activity[0].action, u'Removed')
         self.assertEqual(reserved_system.activity[0].old_value,
                 u'User:%s:reserve' % user.user_name)
         # systems owned by the user should be transferred to the caller
         self.assertEqual(owned_system.owner.user_name, data_setup.ADMIN_USER)
         self.assertEqual(owned_system.activity[0].field_name, u'Owner')
         self.assertEqual(owned_system.activity[0].action, u'Changed')
         self.assertEqual(owned_system.activity[0].old_value, user.user_name)
         self.assertEqual(owned_system.activity[0].new_value, data_setup.ADMIN_USER)
         # pools owned by the user should be transferred to the caller
         self.assertEqual(owned_pool.owner.user_name, data_setup.ADMIN_USER)
         self.assertEqual(owned_pool.activity[0].field_name, u'Owner')
         self.assertEqual(owned_pool.activity[0].action, u'Changed')
         self.assertEqual(owned_pool.activity[0].old_value, user.user_name)
         self.assertEqual(owned_pool.activity[0].new_value, data_setup.ADMIN_USER)
         # group membership/ownership should be removed
         self.assertNotIn(group, user.groups)
         self.assertNotIn(user, group.users)
         self.assertFalse(group.has_owner(user))
         self.assertEqual(group.activity[-1].field_name, u'User')
         self.assertEqual(group.activity[-1].action, u'Removed')
         self.assertEqual(group.activity[-1].old_value, user.user_name)
コード例 #25
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_system_status(self):
     excluded = data_setup.create_system(status=SystemStatus.manual)
     included = data_setup.create_system(status=SystemStatus.automated)
     self.check_filter("""
         <hostRequires>
             <system><status op="==" value="Automated" /></system>
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #26
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_memory(self):
     excluded = data_setup.create_system(memory=128)
     included = data_setup.create_system(memory=1024)
     self.check_filter("""
         <hostRequires>
             <memory op="&gt;=" value="256" />
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #27
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_system_model(self):
     excluded = data_setup.create_system(model=u'grover')
     included = data_setup.create_system(model=u'elmo')
     self.check_filter("""
         <hostRequires>
             <system><model op="=" value="elmo" /></system>
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #28
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_system_vendor(self):
     excluded = data_setup.create_system(vendor=u'apple')
     included = data_setup.create_system(vendor=u'mango')
     self.check_filter("""
         <hostRequires>
             <system><vendor op="!=" value="apple" /></system>
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #29
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_system_lender(self):
     excluded = data_setup.create_system(lender=u'my excluded lender')
     included = data_setup.create_system(lender=u'my included lender')
     self.check_filter("""
         <hostRequires>
             <system><lender op="like" value="%included%" /></system>
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #30
0
ファイル: test_needpropertyxml.py プロジェクト: omps/beaker
 def test_system_serial(self):
     excluded = data_setup.create_system(serial=u'0u812')
     included = data_setup.create_system(serial=u'2112')
     self.check_filter("""
         <hostRequires>
             <system><serial op="=" value="2112" /></system>
         </hostRequires>
         """,
         present=[included], absent=[excluded])
コード例 #31
0
ファイル: test_systems.py プロジェクト: clrkwllms/beaker
 def test_filter_by_group(self):
     # System groups became pools in Beaker 20.0 but we need to continue
     # supporting System/Group search (mapped to pools) for old clients.
     with session.begin():
         pool = data_setup.create_system_pool()
         nopool = data_setup.create_system()
         inpool = data_setup.create_system()
         inpool.pools.append(pool)
     feed_url = urljoin(
         get_server_base(),
         '?' + urlencode({
             'tg_format': 'atom',
             'systemsearch-0.table': 'System/Group',
             'systemsearch-0.operation': 'is',
             'systemsearch-0.value': pool.name
         }))
     feed = lxml.etree.parse(urlopen(feed_url)).getroot()
     self.assertFalse(self.feed_contains_system(feed, nopool.fqdn))
     self.assertTrue(self.feed_contains_system(feed, inpool.fqdn))
コード例 #32
0
ファイル: test_system_search.py プロジェクト: tcler/beaker
 def test_secret_system_visible_when_loaned(self):
     with session.begin():
         secret_system = data_setup.create_system(shared=False, private=True)
         secret_system.loaned = self.user
     b = self.browser
     login(b, user=self.user.user_name, password=u'password')
     b.get(get_server_base())
     search_for_system(b, secret_system)
     b.find_element_by_xpath('//table[@id="widget"]'
             '//tr/td[1][./a/text()="%s"]' % secret_system.fqdn)
コード例 #33
0
    def test_invalid_newowner_errors(self):
        """If an invalid username is passed as a new owner, we expect the
        command to error without changing the system."""
        invalid_username = u'asdfasdfasdf'
        with session.begin():
            user = data_setup.create_user()
            data_setup.create_system()
            self.assertFalse(
                session.query(User).filter_by(
                    user_name=invalid_username).count())

        try:
            run_client([
                'bkr', 'remove-account',
                '--new-owner=%s' % invalid_username, user.user_name
            ])
            self.fail('Expected client to fail due to invalid new owner')
        except ClientError as e:
            self.assertIn('Invalid user name for owner', e.stderr_output)
コード例 #34
0
ファイル: test_recipes_xmlrpc.py プロジェクト: qhsong/beaker
 def test_gets_logs(self):
     with session.begin():
         system = data_setup.create_system(lab_controller=self.lc)
         recipe = data_setup.create_recipe()
         recipe.logs.append(LogRecipe(filename=u'test.log'))
         data_setup.create_job_for_recipes([recipe])
     self.server.auth.login_password(self.lc.user.user_name, u'logmein')
     logs = self.server.recipes.files(recipe.id)
     self.assertEqual(len(logs), 1)
     self.assertEqual(logs[0]['filename'], u'test.log')
コード例 #35
0
 def test_hypervisor(self):
     baremetal = data_setup.create_system(hypervisor=None)
     kvm = data_setup.create_system(hypervisor=u'KVM')
     xen = data_setup.create_system(hypervisor=u'Xen')
     self.check_filter("""
         <hostRequires>
                 <system><hypervisor op="=" value="KVM" /></system>
         </hostRequires>
         """,
         present=[kvm], absent=[baremetal, xen])
     self.check_filter("""
         <hostRequires>
             <and>
                 <hypervisor op="=" value="KVM" />
             </and>
         </hostRequires>
         """,
         present=[kvm], absent=[baremetal, xen])
     self.check_filter("""
         <hostRequires>
                 <system><hypervisor op="=" value="" /></system>
         </hostRequires>
         """,
         present=[baremetal], absent=[kvm, xen])
     self.check_filter("""
         <hostRequires>
             <and>
                 <hypervisor op="=" value="" />
             </and>
         </hostRequires>
         """,
         present=[baremetal], absent=[kvm, xen])
     self.check_filter("""
         <hostRequires/>
         """,
         present=[baremetal, kvm, xen])
     # https://bugzilla.redhat.com/show_bug.cgi?id=886816
     self.check_filter("""
         <hostRequires>
             <hypervisor op="!=" value="KVM" />
         </hostRequires>
         """,
         present=[baremetal, xen], absent=[kvm])
コード例 #36
0
 def test_can_release_system(self):
     with session.begin():
         system = data_setup.create_system(status=SystemStatus.manual)
         user = data_setup.create_user()
         system.reserve_manually('TESTING', user=user)
     self.assertEqual(system.user, user)
     run_client(['bkr', 'system-release', system.fqdn])
     with session.begin():
         session.refresh(system)
         self.assertEqual(system.user, None)
コード例 #37
0
ファイル: test_system_search.py プロジェクト: tcler/beaker
    def test_by_reserved_since(self):
        with session.begin():
            s1 = data_setup.create_system()
            data_setup.create_manual_reservation(s1, start=datetime.datetime(2003, 1, 21, 11, 30, 0))
            s2 = data_setup.create_system(fqdn='aaadvark.testdata')
            data_setup.create_manual_reservation(s2, start=datetime.datetime(2005, 1, 21, 11, 30, 0))
        b = self.browser

        perform_search(b, [('System/Reserved', 'is', '2003-01-21')])
        check_system_search_results(b, present=[s1], absent=[s2])

        perform_search(b, [('System/Reserved', 'before', '2005-1-21')])
        check_system_search_results(b, present=[s1], absent=[s2])

        perform_search(b, [('System/Reserved', 'after', '2005-1-21')])
        check_system_search_results(b, absent=[s1, s2])

        perform_search(b, [('System/Reserved', 'after', '2005-1-1')])
        check_system_search_results(b, present=[s2], absent=[s1])
コード例 #38
0
 def test_shows_current_loan(self):
     b = self.browser
     login(b)
     with session.begin():
         system = data_setup.create_system()
         system.loaned = data_setup.create_user()
     self.go_to_system_view(system)
     usage = b.find_element_by_class_name('system-quick-usage')
     usage.find_element_by_xpath('.//span[contains(@class, "label") and text()="Loaned"]')
     usage.find_element_by_xpath('.//a[text()="%s"]' % system.loaned.user_name)
コード例 #39
0
 def test_secret_system_not_visible(self):
     with session.begin():
         secret_system = data_setup.create_system(shared=False,
                                                  private=True)
     b = self.browser
     login(b, user=self.user.user_name, password=u'password')
     b.get(get_server_base())
     search_for_system(b, secret_system)
     # results grid should be empty
     b.find_element_by_xpath('//table[@id="widget" and not(.//td)]')
コード例 #40
0
 def setUp(self):
     with session.begin():
         self.system = data_setup.create_system()
         user = data_setup.create_user()
         self.activity = CommandActivity(user,
                                         'Just',
                                         'testing',
                                         status=CommandStatus.queued)
         self.system.command_queue.append(self.activity)
     self.browser = self.get_browser()
コード例 #41
0
ファイル: test_watchdog.py プロジェクト: clrkwllms/beaker
 def setUp(self):
     with session.begin():
         self.system = data_setup.create_system(lab_controller=self.get_lc())
         self.recipe = data_setup.create_recipe()
         job = data_setup.create_job_for_recipes([self.recipe])
         self.addCleanup(self.cleanup_job, job)
         data_setup.mark_recipe_installing(self.recipe, system=self.system)
     self.console_log = os.path.join(get_conf().get('CONSOLE_LOGS'), self.system.fqdn)
     self.cached_console_log = os.path.join(get_conf().get('CACHEPATH'), 'recipes',
             str(self.recipe.id // 1000) + '+', str(self.recipe.id), 'console.log')
コード例 #42
0
 def test_get_system_returns_correct_id(self):
     # The bug was that Power.id was overwriting System.id.
     with session.begin():
         # The bug is not observable if the system and power rows both
         # happen to have the same id, which is likely in the test suite
         # since we always create system and power rows together. Create
         # a throwaway system row without power, to ensure the autoincrement
         # ids are not in sync.
         data_setup.create_system(with_power=False)
         system = data_setup.create_system(owner=self.owner)
         self.assertNotEqual(system.id, system.power.id)
         # The bug is only observable to users with access to view power settings.
         self.assertTrue(system.can_view_power(self.owner))
     s = requests.Session()
     requests_login(s, user=self.owner.user_name, password=u'theowner')
     response = s.get(get_server_base() + '/systems/%s/' % system.fqdn,
                      headers={'Accept': 'application/json'})
     response.raise_for_status()
     self.assertEqual(response.json()['id'], system.id)
コード例 #43
0
 def setUp(self):
     with session.begin():
         self.lc = data_setup.create_labcontroller()
         self.system = data_setup.create_system(arch=u'i386', shared=True)
         # The distro tree is only on this lab controller, so when we are
         # picking systems we won't be shown any others left in the db.
         self.distro_tree = data_setup.create_distro_tree(
             arch=u'i386', lab_controllers=[self.lc])
         self.system.lab_controller = self.lc
     self.browser = self.get_browser()
コード例 #44
0
 def test_cannot_power_without_permission(self):
     with session.begin():
         user = data_setup.create_user(password=u'password')
         system = data_setup.create_system(shared=False)
     self.server.auth.login_password(user.user_name, 'password')
     try:
         self.server.systems.power('on', system.fqdn)
         self.fail('should raise')
     except xmlrpclib.Fault, e:
         self.assertIn('does not have permission to power system', e.faultString)
コード例 #45
0
 def test_no_arches(self):
     with session.begin():
         system = data_setup.create_system(lab_controller=self.lc)
         system.arch[:] = []
     login(self.browser)
     provision = self.go_to_provision_tab(system)
     provision.find_element_by_xpath(
         './/p[text()="System must have '
         'at least one supported architecture defined '
         'in order to provision."]')
コード例 #46
0
 def test_cannot_reserve_when_not_logged_in(self):
     with session.begin():
         system = data_setup.create_system()
     server = self.get_server()
     try:
         server.systems.reserve(system.fqdn)
         self.fail('should raise')
     except Exception, e:
         self.assert_('Anonymous access denied' in e.faultString,
                      e.faultString)
コード例 #47
0
ファイル: test_systems.py プロジェクト: clrkwllms/beaker
 def test_xml_filter(self):
     with session.begin():
         module_key = Key.by_name(u'MODULE')
         with_module = data_setup.create_system()
         with_module.key_values_string.extend([
             Key_Value_String(module_key, u'cciss'),
             Key_Value_String(module_key, u'kvm')
         ])
         without_module = data_setup.create_system()
     feed_url = urljoin(
         get_server_base(),
         '?' + urlencode({
             'tg_format': 'atom',
             'list_tgp_order': '-date_modified',
             'xmlsearch': '<key_value key="MODULE" />'
         }))
     feed = lxml.etree.parse(urlopen(feed_url)).getroot()
     self.assert_(self.feed_contains_system(feed, with_module.fqdn))
     self.assert_(not self.feed_contains_system(feed, without_module.fqdn))
コード例 #48
0
 def test_cannot_provision_automated_system(self):
     with session.begin():
         system = data_setup.create_system(
                 owner=User.by_user_name(data_setup.ADMIN_USER),
                 status=u'Automated', shared=True)
         user = data_setup.create_user(password=u'password')
     self.server.auth.login_password(user.user_name, 'password')
     try:
         self.server.systems.provision(system.fqdn, 'distro')
     except xmlrpclib.Fault, e:
         self.assertIn('Reserve a system before provisioning', e.faultString)
コード例 #49
0
ファイル: test_remove_account.py プロジェクト: joyxu/beaker
    def test_close_account_transfer_ownership(self):
        with session.begin():
            new_owner = data_setup.create_user()
            user = data_setup.create_user()
            system = data_setup.create_system(owner=user)

        run_client(['bkr', 'remove-account', '--new-owner=%s' % new_owner.user_name, user.user_name])

        with session.begin():
            session.expire_all()
            self.assertEqual(system.owner, new_owner)
コード例 #50
0
 def test_change_condition(self):
     with session.begin():
         system = data_setup.create_system(
             lab_controller=data_setup.create_labcontroller(),
             status=SystemStatus.automated)
     run_client(['bkr', 'system-modify', '--condition=Manual', system.fqdn])
     with session.begin():
         session.expire_all()
         self.assertEquals(system.status, SystemStatus.manual)
         self.assertEquals(system.activity[0].field_name, u'Status')
         self.assertEquals(system.activity[0].new_value, u'Manual')
コード例 #51
0
 def test_cannot_reserve_automated_system(self):
     with session.begin():
         user = data_setup.create_user(password=u'password')
         system = data_setup.create_system(owner=user, status=u'Automated', shared=True)
     server = self.get_server()
     server.auth.login_password(user.user_name, 'password')
     try:
         server.systems.reserve(system.fqdn)
         self.fail('should raise')
     except xmlrpclib.Fault, e:
         self.assertIn('Cannot manually reserve automated system', e.faultString)
コード例 #52
0
 def test_system_in_use_by_another_user(self):
     with session.begin():
         system = data_setup.create_system(status=SystemStatus.automated,
                                           shared=True,
                                           lab_controller=self.lc)
         job = data_setup.create_job()
         data_setup.mark_job_running(job, system=system)
     b = self.browser
     login(b)
     self.check_system_is_available(system)
     self.check_system_is_not_free(system)
コード例 #53
0
 def test_shared_system(self):
     with session.begin():
         system = data_setup.create_system(status=SystemStatus.automated,
                                           shared=True,
                                           lab_controller=self.lc)
         user = data_setup.create_user(password=u'testing')
     b = self.browser
     login(b, user=user.user_name, password='******')
     self.check_system_is_available(system)
     self.check_system_is_free(system)
     self.check_cannot_take(system)
コード例 #54
0
 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)
コード例 #55
0
 def test_system_activity_entry_is_correctly_truncated(self):
     with session.begin():
         system = data_setup.create_system()
     b = self.browser
     b.get(get_server_base() + 'view/%s' % system.fqdn)
     b.find_element_by_xpath('//button[text()="Report problem"]').click()
     b.find_element_by_name('message').send_keys(u'a' + u'\u044f' * 100)
     b.find_element_by_xpath('//button[text()="Report"]').click()
     # Wait for our success box
     b.find_element_by_xpath('//div[contains(@class, "alert-success")]'
             '/h4[text()="Report sent"]')
コード例 #56
0
 def test_device_with_no_class(self):
     with session.begin():
         system1 = data_setup.create_system()
         system2 = data_setup.create_system()
     device_data = {
         'Devices': [{
             'type': None,
             'bus': u'pci',
             'driver': u'noclass',
             'description': u'Oh so very tacky',
             'vendorID': None,
             'deviceID': None,
             'subsysVendorID': None,
             'subsysDeviceID': None,
         }]
     }
     self.server.push(system1.fqdn, device_data)
     # DeviceClass('NONE') already exists now, so do it again
     # and check that nothing blows up
     self.server.push(system2.fqdn, device_data)
コード例 #57
0
    def setUp(self):

        with session.begin():
            self.system = data_setup.create_system(shared=False)
            self.system_public = data_setup.create_system(shared=False)
            self.user1 = data_setup.create_user()
            self.user2 = data_setup.create_user()
            self.group = data_setup.create_group()
            self.system.custom_access_policy.add_rule(
                permission=SystemPermission.edit_system, user=self.user1)
            self.system.custom_access_policy.add_rule(
                permission=SystemPermission.control_system, user=self.user2)
            self.system.custom_access_policy.add_rule(
                permission=SystemPermission.control_system, group=self.group)
            self.system_public.custom_access_policy.add_rule(
                permission=SystemPermission.control_system, everybody=True)
            self.pool = data_setup.create_system_pool(systems=[self.system])
            self.user3 = data_setup.create_user()
            self.pool.access_policy.add_rule(
                permission=SystemPermission.edit_system, user=self.user3)
コード例 #58
0
    def test_export_install_options(self):
        with session.begin():
            system = data_setup.create_system(arch=u'i386')
            distro_tree = data_setup.create_distro_tree(arch=u'i386')
            system.provisions[distro_tree.arch] = Provision(
                arch=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')
            system.provisions[distro_tree.arch]\
                .provision_families[distro_tree.distro.osversion.osmajor] = \
                    ProvisionFamily(osmajor=distro_tree.distro.osversion.osmajor,
                        ks_meta=u'some_ks_meta_var=2', kernel_options=u'some_kernel_option=3',
                        kernel_options_post=u'some_kernel_option=4')
            system.provisions[distro_tree.arch]\
                .provision_families[distro_tree.distro.osversion.osmajor]\
                .provision_family_updates[distro_tree.distro.osversion] = \
                    ProvisionFamilyUpdate(osversion=distro_tree.distro.osversion,
                        ks_meta=u'some_ks_meta_var=3', kernel_options=u'some_kernel_option=5',
                        kernel_options_post=u'some_kernel_option=6')

        login(self.browser)
        csv_request = self.get_csv('install')
        csv_rows = [
            row for row in csv.DictReader(csv_request)
            if row['fqdn'] == system.fqdn
        ]
        self.assertEquals(csv_rows[0]['arch'], 'i386')
        self.assertEquals(csv_rows[0]['family'], '')
        self.assertEquals(csv_rows[0]['update'], '')
        self.assertEquals(csv_rows[0]['ks_meta'], 'some_ks_meta_var=1')
        self.assertEquals(csv_rows[0]['kernel_options'],
                          'some_kernel_option=1')
        self.assertEquals(csv_rows[0]['kernel_options_post'],
                          'some_kernel_option=2')
        self.assertEquals(csv_rows[1]['arch'], 'i386')
        self.assertEquals(csv_rows[1]['family'],
                          unicode(distro_tree.distro.osversion.osmajor))
        self.assertEquals(csv_rows[1]['update'], '')
        self.assertEquals(csv_rows[1]['ks_meta'], 'some_ks_meta_var=2')
        self.assertEquals(csv_rows[1]['kernel_options'],
                          'some_kernel_option=3')
        self.assertEquals(csv_rows[1]['kernel_options_post'],
                          'some_kernel_option=4')
        self.assertEquals(csv_rows[2]['arch'], 'i386')
        self.assertEquals(csv_rows[2]['family'],
                          unicode(distro_tree.distro.osversion.osmajor))
        self.assertEquals(csv_rows[2]['update'],
                          unicode(distro_tree.distro.osversion.osminor))
        self.assertEquals(csv_rows[2]['ks_meta'], 'some_ks_meta_var=3')
        self.assertEquals(csv_rows[2]['kernel_options'],
                          'some_kernel_option=5')
        self.assertEquals(csv_rows[2]['kernel_options_post'],
                          'some_kernel_option=6')
コード例 #59
0
ファイル: test_workflow_simple.py プロジェクト: tcler/beaker
 def test_ignore_system_status(self):
     with session.begin():
         lc = data_setup.create_labcontroller()
         system = data_setup.create_system(lab_controller=lc,
                                           status=SystemStatus.broken)
     out = run_client([
         'bkr', 'workflow-simple', '--distro', self.distro.name,
         '--machine', system.fqdn, '--ignore-system-status', '--task',
         self.task.name, '--dry-run', '--pretty-xml'
     ])
     self.assertIn('<hostRequires force="%s"/>' % system.fqdn, out)
コード例 #60
0
    def test_no_action(self):
        with session.begin():
            lc = data_setup.create_labcontroller()
            system = data_setup.create_system(lab_controller=lc)

        run_client([
            'bkr', 'system-power', '--action', 'none', '--clear-netboot',
            system.fqdn
        ])
        self.assertEqual(len(system.command_queue), 1)
        self.assertEqual(system.command_queue[0].action, 'clear_netboot')