KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use _create_reverify_request method in autotest

Best Python code snippet using autotest_python

monitor_db_functional_test.py

Source:monitor_db_functional_test.py

...418        self._finish_parsing()419    def _finish_parsing(self):420        self.mock_drone_manager.finish_process(_PidfileType.PARSE)421        self._run_dispatcher()422    def _create_reverify_request(self):423        host = self.hosts[0]424        models.SpecialTask.schedule_special_task(425                host=host, task=models.SpecialTask.Task.VERIFY)426        return host427    def test_requested_reverify(self):428        host = self._create_reverify_request()429        self._run_dispatcher()430        self._check_host_status(host, HostStatus.VERIFYING)431        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)432        self._run_dispatcher()433        self._check_host_status(host, HostStatus.READY)434    def test_requested_reverify_failure(self):435        host = self._create_reverify_request()436        self._run_dispatcher()437        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,438                                               exit_status=256)439        self._run_dispatcher() # repair440        self._check_host_status(host, HostStatus.REPAIRING)441        self.mock_drone_manager.finish_process(_PidfileType.REPAIR)442        self._run_dispatcher()443        self._check_host_status(host, HostStatus.READY)444    def _setup_for_do_not_verify(self):445        self._initialize_test()446        job, queue_entry = self._make_job_and_queue_entry()447        queue_entry.host.protection = host_protections.Protection.DO_NOT_VERIFY448        queue_entry.host.save()449        return queue_entry450    def test_do_not_verify_job(self):451        queue_entry = self._setup_for_do_not_verify()452        self._run_dispatcher() # runs job directly453        self._finish_job(queue_entry)454    def test_do_not_verify_job_with_cleanup(self):455        queue_entry = self._setup_for_do_not_verify()456        queue_entry.job.reboot_before = model_attributes.RebootBefore.ALWAYS457        queue_entry.job.save()458        self._run_dispatcher() # cleanup459        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)460        self._run_dispatcher() # job461        self._finish_job(queue_entry)462    def test_do_not_verify_pre_job_cleanup_failure(self):463        queue_entry = self._setup_for_do_not_verify()464        queue_entry.job.reboot_before = model_attributes.RebootBefore.ALWAYS465        queue_entry.job.save()466        self._run_dispatcher() # cleanup467        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP,468                                               exit_status=256)469        self._run_dispatcher() # failure ignored; job runs470        self._finish_job(queue_entry)471    def test_do_not_verify_post_job_cleanup_failure(self):472        queue_entry = self._setup_for_do_not_verify()473        queue_entry.job.reboot_after = model_attributes.RebootAfter.ALWAYS474        queue_entry.job.save()475        self._run_post_job_cleanup_failure_up_to_repair(queue_entry,476                                                        include_verify=False)477        # failure ignored, host still set to Ready478        self._check_statuses(queue_entry, HqeStatus.COMPLETED, HostStatus.READY)479        self._run_dispatcher() # nothing else runs480        self._assert_nothing_is_running()481    def test_do_not_verify_requested_reverify_failure(self):482        host = self._create_reverify_request()483        host.protection = host_protections.Protection.DO_NOT_VERIFY484        host.save()485        self._run_dispatcher()486        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,487                                               exit_status=256)488        self._run_dispatcher()489        self._check_host_status(host, HostStatus.READY) # ignore failure490        self._assert_nothing_is_running()491    def test_job_abort_in_verify(self):492        self._initialize_test()493        job = self._create_job(hosts=[1])494        queue_entries = list(job.hostqueueentry_set.all())495        self._run_dispatcher() # launches verify496        self._check_statuses(queue_entries[0], HqeStatus.VERIFYING)497        job.hostqueueentry_set.update(aborted=True)498        self._run_dispatcher() # kills verify, launches cleanup499        self.assert_(self.mock_drone_manager.was_last_process_killed(500                _PidfileType.VERIFY, set([signal.SIGKILL])))501        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)502        self._run_dispatcher()503    def test_job_abort(self):504        self._initialize_test()505        job = self._create_job(hosts=[1])506        job.run_reset = False507        job.save()508        queue_entries = list(job.hostqueueentry_set.all())509        self._run_dispatcher() # launches job510        self._check_statuses(queue_entries[0], HqeStatus.RUNNING)511        job.hostqueueentry_set.update(aborted=True)512        self._run_dispatcher() # kills job, launches gathering513        self._check_statuses(queue_entries[0], HqeStatus.GATHERING)514        self.mock_drone_manager.finish_process(_PidfileType.GATHER)515        self._run_dispatcher() # launches parsing + cleanup516        queue_entry = job.hostqueueentry_set.all()[0]517        self._finish_parsing()518        # The abort will cause gathering to launch a cleanup.519        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)520        self._run_dispatcher()521        self.mock_drone_manager.finish_process(_PidfileType.RESET)522        self._run_dispatcher()523    def test_job_abort_queued_synchronous(self):524        self._initialize_test()525        job = self._create_job(hosts=[1,2])526        job.synch_count = 2527        job.save()528        job.hostqueueentry_set.update(aborted=True)529        self._run_dispatcher()530        for host_queue_entry in job.hostqueueentry_set.all():531            self.assertEqual(host_queue_entry.status,532                             HqeStatus.ABORTED)533    def test_no_pidfile_leaking(self):534        self._initialize_test()535        self.test_simple_job()536        self.mock_drone_manager.refresh()537        self.assertEquals(self.mock_drone_manager._pidfiles, {})538        self.test_job_abort_in_verify()539        self.mock_drone_manager.refresh()540        self.assertEquals(self.mock_drone_manager._pidfiles, {})541        self.test_job_abort()542        self.mock_drone_manager.refresh()543        self.assertEquals(self.mock_drone_manager._pidfiles, {})544    def _make_job_and_queue_entry(self):545        job = self._create_job(hosts=[1])546        queue_entry = job.hostqueueentry_set.all()[0]547        return job, queue_entry548    def test_recover_running_no_process(self):549        # recovery should re-execute a Running HQE if no process is found550        _, queue_entry = self._make_job_and_queue_entry()551        queue_entry.status = HqeStatus.RUNNING552        queue_entry.execution_subdir = '1-myuser/host1'553        queue_entry.save()554        queue_entry.host.status = HostStatus.RUNNING555        queue_entry.host.save()556        self._initialize_test()557        self._run_dispatcher()558        self._finish_job(queue_entry)559    def test_recover_verifying_hqe_no_special_task(self):560        # recovery should move a Resetting HQE with no corresponding561        # Verify or Reset SpecialTask back to Queued.562        _, queue_entry = self._make_job_and_queue_entry()563        queue_entry.status = HqeStatus.RESETTING564        queue_entry.save()565        # make some dummy SpecialTasks that shouldn't count566        models.SpecialTask.objects.create(567                host=queue_entry.host,568                task=models.SpecialTask.Task.RESET,569                requested_by=models.User.current_user())570        models.SpecialTask.objects.create(571                host=queue_entry.host,572                task=models.SpecialTask.Task.CLEANUP,573                queue_entry=queue_entry,574                is_complete=True,575                requested_by=models.User.current_user())576        self._initialize_test()577        self._check_statuses(queue_entry, HqeStatus.QUEUED)578    def _test_recover_verifying_hqe_helper(self, task, pidfile_type):579        _, queue_entry = self._make_job_and_queue_entry()580        queue_entry.status = HqeStatus.VERIFYING581        queue_entry.save()582        special_task = models.SpecialTask.objects.create(583                host=queue_entry.host, task=task, queue_entry=queue_entry)584        self._initialize_test()585        self._run_dispatcher()586        self.mock_drone_manager.finish_process(pidfile_type)587        self._run_dispatcher()588        # don't bother checking the rest of the job execution, as long as the589        # SpecialTask ran590    def test_recover_verifying_hqe_with_cleanup(self):591        # recover an HQE that was in pre-job cleanup592        self._test_recover_verifying_hqe_helper(models.SpecialTask.Task.CLEANUP,593                                                _PidfileType.CLEANUP)594    def test_recover_verifying_hqe_with_verify(self):595        # recover an HQE that was in pre-job verify596        self._test_recover_verifying_hqe_helper(models.SpecialTask.Task.VERIFY,597                                                _PidfileType.VERIFY)598    def test_recover_parsing(self):599        self._initialize_test()600        job, queue_entry = self._make_job_and_queue_entry()601        job.run_verify = False602        job.run_reset = False603        job.reboot_after = model_attributes.RebootAfter.NEVER604        job.save()605        self._run_dispatcher() # launches job606        self.mock_drone_manager.finish_process(_PidfileType.JOB)607        self._run_dispatcher() # launches parsing608        # now "restart" the scheduler609        self._create_dispatcher()610        self._initialize_test()611        self._run_dispatcher()612        self.mock_drone_manager.finish_process(_PidfileType.PARSE)613        self._run_dispatcher()614    def test_recover_parsing__no_process_already_aborted(self):615        _, queue_entry = self._make_job_and_queue_entry()616        queue_entry.execution_subdir = 'host1'617        queue_entry.status = HqeStatus.PARSING618        queue_entry.aborted = True619        queue_entry.save()620        self._initialize_test()621        self._run_dispatcher()622    def test_job_scheduled_just_after_abort(self):623        # test a pretty obscure corner case where a job is aborted while queued,624        # another job is ready to run, and throttling is active. the post-abort625        # cleanup must not be pre-empted by the second job.626        # This test kind of doesn't make sense anymore after verify+cleanup627        # were merged into reset.  It should maybe just be removed.628        job1, queue_entry1 = self._make_job_and_queue_entry()629        queue_entry1.save()630        job2, queue_entry2 = self._make_job_and_queue_entry()631        job2.reboot_before = model_attributes.RebootBefore.IF_DIRTY632        job2.save()633        self.mock_drone_manager.process_capacity = 0634        self._run_dispatcher() # schedule job1, but won't start verify635        job1.hostqueueentry_set.update(aborted=True)636        self.mock_drone_manager.process_capacity = 100637        self._run_dispatcher() # reset must run here, not verify for job2638        self._check_statuses(queue_entry1, HqeStatus.ABORTED,639                             HostStatus.RESETTING)640        self.mock_drone_manager.finish_process(_PidfileType.RESET)641        self._run_dispatcher() # now verify starts for job2642        self._check_statuses(queue_entry2, HqeStatus.RUNNING,643                             HostStatus.RUNNING)644    def test_reverify_interrupting_pre_job(self):645        # ensure things behave sanely if a reverify is scheduled in the middle646        # of pre-job actions647        _, queue_entry = self._make_job_and_queue_entry()648        self._run_dispatcher() # pre-job verify649        self._create_reverify_request()650        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,651                                               exit_status=256)652        self._run_dispatcher() # repair653        self.mock_drone_manager.finish_process(_PidfileType.REPAIR)654        self._run_dispatcher() # reverify runs now655        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)656        self._run_dispatcher() # pre-job verify657        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)658        self._run_dispatcher() # and job runs...659        self._check_statuses(queue_entry, HqeStatus.RUNNING, HostStatus.RUNNING)660        self._finish_job(queue_entry) # reverify has been deleted661        self._check_statuses(queue_entry, HqeStatus.COMPLETED,662                             HostStatus.READY)663        self._assert_nothing_is_running()664    def test_reverify_while_job_running(self):665        # once a job is running, a reverify must not be allowed to preempt666        # Gathering667        _, queue_entry = self._make_job_and_queue_entry()668        self._run_pre_job_verify(queue_entry)669        self._run_dispatcher() # job runs670        self._create_reverify_request()671        # make job end with a signal, so gathering will run672        self.mock_drone_manager.finish_process(_PidfileType.JOB,673                                               exit_status=271)674        self._run_dispatcher() # gathering must start675        self.mock_drone_manager.finish_process(_PidfileType.GATHER)676        self._run_dispatcher() # parsing and cleanup677        self._finish_parsing()678        self._run_dispatcher() # now reverify runs679        self._check_statuses(queue_entry, HqeStatus.FAILED,680                             HostStatus.VERIFYING)681        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)682        self._run_dispatcher()683        self._check_host_status(queue_entry.host, HostStatus.READY)684    def test_reverify_while_host_pending(self):685        # ensure that if a reverify is scheduled while a host is in Pending, it686        # won't run until the host is actually free687        job = self._create_job(hosts=[1,2])688        queue_entry = job.hostqueueentry_set.get(host__hostname='host1')689        job.synch_count = 2690        job.save()691        host2 = self.hosts[1]692        host2.locked = True693        host2.save()694        self._run_dispatcher() # verify host1695        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)696        self._run_dispatcher() # host1 Pending697        self._check_statuses(queue_entry, HqeStatus.PENDING, HostStatus.PENDING)698        self._create_reverify_request()699        self._run_dispatcher() # nothing should happen here700        self._check_statuses(queue_entry, HqeStatus.PENDING, HostStatus.PENDING)701        # now let the job run702        host2.locked = False703        host2.save()704        self._run_dispatcher() # verify host2705        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)706        self._run_dispatcher() # run job707        self._finish_job(queue_entry)708        # the reverify should now be running709        self._check_statuses(queue_entry, HqeStatus.COMPLETED,710                             HostStatus.VERIFYING)711        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)712        self._run_dispatcher()...

monitor_db_functional_unittest.py

Source:monitor_db_functional_unittest.py

...400        self._run_dispatcher()401        self._check_entry_status(queue_entry, HqeStatus.ARCHIVING)402        self.mock_drone_manager.finish_process(_PidfileType.ARCHIVE)403        self._run_dispatcher()404    def _create_reverify_request(self):405        host = self.hosts[0]406        models.SpecialTask.schedule_special_task(407            host=host, task=models.SpecialTask.Task.VERIFY)408        return host409    def test_requested_reverify(self):410        host = self._create_reverify_request()411        self._run_dispatcher()412        self._check_host_status(host, HostStatus.VERIFYING)413        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)414        self._run_dispatcher()415        self._check_host_status(host, HostStatus.READY)416    def test_requested_reverify_failure(self):417        host = self._create_reverify_request()418        self._run_dispatcher()419        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,420                                               exit_status=256)421        self._run_dispatcher()  # repair422        self._check_host_status(host, HostStatus.REPAIRING)423        self.mock_drone_manager.finish_process(_PidfileType.REPAIR)424        self._run_dispatcher()425        self._check_host_status(host, HostStatus.READY)426    def _setup_for_do_not_verify(self):427        self._initialize_test()428        job, queue_entry = self._make_job_and_queue_entry()429        queue_entry.host.protection = host_protections.Protection.DO_NOT_VERIFY430        queue_entry.host.save()431        return queue_entry432    def test_do_not_verify_job(self):433        queue_entry = self._setup_for_do_not_verify()434        self._run_dispatcher()  # runs job directly435        self._finish_job(queue_entry)436    def test_do_not_verify_job_with_cleanup(self):437        queue_entry = self._setup_for_do_not_verify()438        queue_entry.job.reboot_before = model_attributes.RebootBefore.ALWAYS439        queue_entry.job.save()440        self._run_dispatcher()  # cleanup441        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)442        self._run_dispatcher()  # job443        self._finish_job(queue_entry)444    def test_do_not_verify_pre_job_cleanup_failure(self):445        queue_entry = self._setup_for_do_not_verify()446        queue_entry.job.reboot_before = model_attributes.RebootBefore.ALWAYS447        queue_entry.job.save()448        self._run_dispatcher()  # cleanup449        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP,450                                               exit_status=256)451        self._run_dispatcher()  # failure ignored; job runs452        self._finish_job(queue_entry)453    def test_do_not_verify_post_job_cleanup_failure(self):454        queue_entry = self._setup_for_do_not_verify()455        self._run_post_job_cleanup_failure_up_to_repair(queue_entry,456                                                        include_verify=False)457        # failure ignored, host still set to Ready458        self._check_statuses(queue_entry, HqeStatus.COMPLETED, HostStatus.READY)459        self._run_dispatcher()  # nothing else runs460        self._assert_nothing_is_running()461    def test_do_not_verify_requested_reverify_failure(self):462        host = self._create_reverify_request()463        host.protection = host_protections.Protection.DO_NOT_VERIFY464        host.save()465        self._run_dispatcher()466        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,467                                               exit_status=256)468        self._run_dispatcher()469        self._check_host_status(host, HostStatus.READY)  # ignore failure470        self._assert_nothing_is_running()471    def test_job_abort_in_verify(self):472        self._initialize_test()473        job = self._create_job(hosts=[1])474        self._run_dispatcher()  # launches verify475        job.hostqueueentry_set.update(aborted=True)476        self._run_dispatcher()  # kills verify, launches cleanup477        self.assert_(self.mock_drone_manager.was_last_process_killed(478            _PidfileType.VERIFY))479        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)480        self._run_dispatcher()481    def test_job_abort(self):482        self._initialize_test()483        job = self._create_job(hosts=[1])484        job.run_verify = False485        job.save()486        self._run_dispatcher()  # launches job487        job.hostqueueentry_set.update(aborted=True)488        self._run_dispatcher()  # kills job, launches gathering489        self.assert_(self.mock_drone_manager.was_last_process_killed(490            _PidfileType.JOB))491        self.mock_drone_manager.finish_process(_PidfileType.GATHER)492        self._run_dispatcher()  # launches parsing + cleanup493        queue_entry = job.hostqueueentry_set.all()[0]494        self._finish_parsing_and_cleanup(queue_entry)495    def test_job_abort_queued_synchronous(self):496        self._initialize_test()497        job = self._create_job(hosts=[1, 2])498        job.synch_count = 2499        job.save()500        job.hostqueueentry_set.update(aborted=True)501        self._run_dispatcher()502        for host_queue_entry in job.hostqueueentry_set.all():503            self.assertEqual(host_queue_entry.status,504                             HqeStatus.ABORTED)505    def test_no_pidfile_leaking(self):506        self._initialize_test()507        self.test_simple_job()508        self.assertEquals(self.mock_drone_manager._pidfiles, {})509        self.test_job_abort_in_verify()510        self.assertEquals(self.mock_drone_manager._pidfiles, {})511        self.test_job_abort()512        self.assertEquals(self.mock_drone_manager._pidfiles, {})513    def _make_job_and_queue_entry(self):514        job = self._create_job(hosts=[1])515        queue_entry = job.hostqueueentry_set.all()[0]516        return job, queue_entry517    def test_recover_running_no_process(self):518        # recovery should re-execute a Running HQE if no process is found519        _, queue_entry = self._make_job_and_queue_entry()520        queue_entry.status = HqeStatus.RUNNING521        queue_entry.execution_subdir = '1-myuser/host1'522        queue_entry.save()523        queue_entry.host.status = HostStatus.RUNNING524        queue_entry.host.save()525        self._initialize_test()526        self._run_dispatcher()527        self._finish_job(queue_entry)528    def test_recover_verifying_hqe_no_special_task(self):529        # recovery should fail on a Verifing HQE with no corresponding530        # Verify or Cleanup SpecialTask531        _, queue_entry = self._make_job_and_queue_entry()532        queue_entry.status = HqeStatus.VERIFYING533        queue_entry.save()534        # make some dummy SpecialTasks that shouldn't count535        models.SpecialTask.objects.create(536            host=queue_entry.host,537            task=models.SpecialTask.Task.VERIFY,538            requested_by=models.User.current_user())539        models.SpecialTask.objects.create(540            host=queue_entry.host,541            task=models.SpecialTask.Task.CLEANUP,542            queue_entry=queue_entry,543            is_complete=True,544            requested_by=models.User.current_user())545        self.assertRaises(host_scheduler.SchedulerError, self._initialize_test)546    def _test_recover_verifying_hqe_helper(self, task, pidfile_type):547        _, queue_entry = self._make_job_and_queue_entry()548        queue_entry.status = HqeStatus.VERIFYING549        queue_entry.save()550        special_task = models.SpecialTask.objects.create(551            host=queue_entry.host, task=task, queue_entry=queue_entry)552        self._initialize_test()553        self._run_dispatcher()554        self.mock_drone_manager.finish_process(pidfile_type)555        self._run_dispatcher()556        # don't bother checking the rest of the job execution, as long as the557        # SpecialTask ran558    def test_recover_verifying_hqe_with_cleanup(self):559        # recover an HQE that was in pre-job cleanup560        self._test_recover_verifying_hqe_helper(models.SpecialTask.Task.CLEANUP,561                                                _PidfileType.CLEANUP)562    def test_recover_verifying_hqe_with_verify(self):563        # recover an HQE that was in pre-job verify564        self._test_recover_verifying_hqe_helper(models.SpecialTask.Task.VERIFY,565                                                _PidfileType.VERIFY)566    def test_recover_pending_hqes_with_group(self):567        # recover a group of HQEs that are in Pending, in the same group (e.g.,568        # in a job with atomic hosts)569        job = self._create_job(hosts=[1, 2], atomic_group=1)570        job.save()571        job.hostqueueentry_set.all().update(status=HqeStatus.PENDING)572        self._initialize_test()573        for queue_entry in job.hostqueueentry_set.all():574            self.assertEquals(queue_entry.status, HqeStatus.STARTING)575    def test_recover_parsing(self):576        self._initialize_test()577        job, queue_entry = self._make_job_and_queue_entry()578        job.run_verify = False579        job.reboot_after = model_attributes.RebootAfter.NEVER580        job.save()581        self._run_dispatcher()  # launches job582        self.mock_drone_manager.finish_process(_PidfileType.JOB)583        self._run_dispatcher()  # launches parsing584        # now "restart" the scheduler585        self._create_dispatcher()586        self._initialize_test()587        self._run_dispatcher()588        self.mock_drone_manager.finish_process(_PidfileType.PARSE)589        self._run_dispatcher()590    def test_recover_parsing__no_process_already_aborted(self):591        _, queue_entry = self._make_job_and_queue_entry()592        queue_entry.execution_subdir = 'host1'593        queue_entry.status = HqeStatus.PARSING594        queue_entry.aborted = True595        queue_entry.save()596        self._initialize_test()597        self._run_dispatcher()598    def test_job_scheduled_just_after_abort(self):599        # test a pretty obscure corner case where a job is aborted while queued,600        # another job is ready to run, and throttling is active. the post-abort601        # cleanup must not be pre-empted by the second job.602        job1, queue_entry1 = self._make_job_and_queue_entry()603        job2, queue_entry2 = self._make_job_and_queue_entry()604        self.mock_drone_manager.process_capacity = 0605        self._run_dispatcher()  # schedule job1, but won't start verify606        job1.hostqueueentry_set.update(aborted=True)607        self.mock_drone_manager.process_capacity = 100608        self._run_dispatcher()  # cleanup must run here, not verify for job2609        self._check_statuses(queue_entry1, HqeStatus.ABORTED,610                             HostStatus.CLEANING)611        self.mock_drone_manager.finish_process(_PidfileType.CLEANUP)612        self._run_dispatcher()  # now verify starts for job2613        self._check_statuses(queue_entry2, HqeStatus.VERIFYING,614                             HostStatus.VERIFYING)615    def test_reverify_interrupting_pre_job(self):616        # ensure things behave sanely if a reverify is scheduled in the middle617        # of pre-job actions618        _, queue_entry = self._make_job_and_queue_entry()619        self._run_dispatcher()  # pre-job verify620        self._create_reverify_request()621        self.mock_drone_manager.finish_process(_PidfileType.VERIFY,622                                               exit_status=256)623        self._run_dispatcher()  # repair624        self.mock_drone_manager.finish_process(_PidfileType.REPAIR)625        self._run_dispatcher()  # reverify runs now626        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)627        self._run_dispatcher()  # pre-job verify628        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)629        self._run_dispatcher()  # and job runs...630        self._check_statuses(queue_entry, HqeStatus.RUNNING, HostStatus.RUNNING)631        self._finish_job(queue_entry)  # reverify has been deleted632        self._check_statuses(queue_entry, HqeStatus.COMPLETED,633                             HostStatus.READY)634        self._assert_nothing_is_running()635    def test_reverify_while_job_running(self):636        # once a job is running, a reverify must not be allowed to preempt637        # Gathering638        _, queue_entry = self._make_job_and_queue_entry()639        self._run_pre_job_verify(queue_entry)640        self._run_dispatcher()  # job runs641        self._create_reverify_request()642        # make job end with a signal, so gathering will run643        self.mock_drone_manager.finish_process(_PidfileType.JOB,644                                               exit_status=271)645        self._run_dispatcher()  # gathering must start646        self.mock_drone_manager.finish_process(_PidfileType.GATHER)647        self._run_dispatcher()  # parsing and cleanup648        self._finish_parsing_and_cleanup(queue_entry)649        self._run_dispatcher()  # now reverify runs650        self._check_statuses(queue_entry, HqeStatus.FAILED,651                             HostStatus.VERIFYING)652        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)653        self._run_dispatcher()654        self._check_host_status(queue_entry.host, HostStatus.READY)655    def test_reverify_while_host_pending(self):656        # ensure that if a reverify is scheduled while a host is in Pending, it657        # won't run until the host is actually free658        job = self._create_job(hosts=[1, 2])659        queue_entry = job.hostqueueentry_set.get(host__hostname='host1')660        job.synch_count = 2661        job.save()662        host2 = self.hosts[1]663        host2.locked = True664        host2.save()665        self._run_dispatcher()  # verify host1666        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)667        self._run_dispatcher()  # host1 Pending668        self._check_statuses(queue_entry, HqeStatus.PENDING, HostStatus.PENDING)669        self._create_reverify_request()670        self._run_dispatcher()  # nothing should happen here671        self._check_statuses(queue_entry, HqeStatus.PENDING, HostStatus.PENDING)672        # now let the job run673        host2.locked = False674        host2.save()675        self._run_dispatcher()  # verify host2676        self.mock_drone_manager.finish_process(_PidfileType.VERIFY)677        self._run_dispatcher()  # run job678        self._finish_job(queue_entry)679        # need to explicitly finish host1's post-job cleanup680        self.mock_drone_manager.finish_specific_process(681            'hosts/host1/4-cleanup', drone_manager.AUTOSERV_PID_FILE)682        self._run_dispatcher()683        # the reverify should now be running...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.