Python health_check.Retriable类代码示例

 def test_failed_secondary_health_check(self):
   """Verifies that a secondary health check is not invoked when a primary check fails"""
   task = self.create_task(0, 'a')
   self._health_check_a.health(task).AndReturn(Retriable.alive())
   self._health_check_b.health(task).AndReturn(Retriable.dead())
   health_check = ChainedHealthCheck(self._health_check_a, self._health_check_b)
   self.replay()
   assert health_check.health(task) == Retriable.dead()
   self.verify()

 def test_simple_chained_health_check(self):
   """Verify successful health check"""
   task = self.create_task(0, 'a')
   self._health_check_a.health(task).AndReturn(Retriable.alive())
   self._health_check_b.health(task).AndReturn(Retriable.alive())
   health_check = ChainedHealthCheck(self._health_check_a, self._health_check_b)
   self.replay()
   assert health_check.health(task) == Retriable.alive()
   self.verify()

 def test_http_health_check(self):
   """Verify successful and failed http health checks for a task"""
   task_a = self.create_task(0, 'a')
   self.expect_http_signaler_creation()
   self.expect_health_check()
   self.expect_health_check(status=False)
   self.replay()
   assert self._http_health_check.health(task_a) == Retriable.alive()
   assert self._http_health_check.health(task_a) == Retriable.dead()
   self.verify()

 def test_instancewatcher_http_health_check_one_http_signaler(self):
   """Verifies that upon multiple http health checks only one HttpHealthChecker is created"""
   task = self.create_task(0, 'a')
   self.expect_http_signaler_creation()
   self.expect_health_check()
   self.expect_health_check()
   self.replay()
   assert self._smart_health_check.health(task) == Retriable.alive()
   assert self._smart_health_check.health(task) == Retriable.alive()
   self.verify()

 def test_unmatched_host_port(self):
   """Test if an instance with a modified a (host, port) triggers a new http health checker creation"""
   instance_id = 0
   task_a = self.create_task(instance_id, 'a')
   self.expect_http_signaler_creation()
   self.expect_health_check()
   task_b = self.create_task(instance_id, 'b', host='host-b', port=44444)
   self.expect_http_signaler_creation(host='host-b', port=44444)
   self.expect_health_check()
   self.replay()
   assert self._http_health_check.health(task_a) == Retriable.alive()
   assert self._http_health_check.health(task_b) == Retriable.alive()
   self.verify()

 def test_instancewatcher_http_health_check(self):
   """Verifies that http health check is performed if the task has a health port"""
   task = self.create_task(0, 'a')
   self.expect_http_signaler_creation()
   self.expect_health_check(status=False)
   self.replay()
   assert self._smart_health_check.health(task) == Retriable.dead()
   self.verify()

 def setup_health_checks(cls, mock_api):
   mock_health_check = Mock(spec=StatusHealthCheck)
   mock_health_check.health.return_value = Retriable.alive()
   return mock_health_check

 def test_health_statuses(self):
   """Verfies that the health status tuple (health, retry_status) are as expected"""
   assert Retriable.alive() == (True, True)
   assert Retriable.dead() == (False, True)
   assert NotRetriable.alive() == (True, False)
   assert NotRetriable.dead() == (False, False)

 def test_changed_task_id(self):
   """Verifes that an instance with a different task id causes the health check to fail"""
   task_a = self.create_task(0, 'a')
   task_b = self.create_task(0, 'b')
   assert self._status_health_check.health(task_a) == Retriable.alive()
   assert self._status_health_check.health(task_b) == NotRetriable.dead()

 def test_failed_status_health_check(self):
   """Verify that the health check fails for tasks in a state other than RUNNING"""
   pending_task = self.create_task(0, 'a', status=PENDING)
   failed_task = self.create_task(1, 'b', status=FAILED)
   assert self._status_health_check.health(pending_task) == Retriable.dead()
   assert self._status_health_check.health(failed_task) == Retriable.dead()

 def test_simple_status_health_check(self):
   """Verify that running instances are reported healthy"""
   task_a = self.create_task(0, 'a')
   task_b = self.create_task(1, 'b')
   assert self._status_health_check.health(task_a) == Retriable.alive()
   assert self._status_health_check.health(task_b) == Retriable.alive()

 def setup_health_checks(cls, mock_api):
   mock_health_check = Mock(spec=InstanceWatcherHealthCheck)
   mock_health_check.health.return_value = Retriable.alive()
   return mock_health_check

 def test_instancewatcher_health_check(self):
   """Verifies that if the task has no health port, only status check is performed"""
   task = self.create_task(0, 'a', port=None)
   self.replay()
   assert self._smart_health_check.health(task) == Retriable.alive()
   self.verify()