Esempio n. 1
0
 def setUp(self):
   self._scheduler = create_autospec(spec=SchedulerThriftApiSpec, instance=True)
   self._quota_checker = QuotaCheck(self._scheduler)
   self._role = 'mesos'
   self._name = 'quotajob'
   self._env = 'test'
   self._job_key = JobKey(name=self._name, environment=self._env, role=self._role)
Esempio n. 2
0
 def setUp(self):
     self._scheduler = Mock()
     self._quota_checker = QuotaCheck(self._scheduler)
     self._role = 'mesos'
     self._name = 'quotajob'
     self._env = 'test'
     self._job_key = JobKey(name=self._name,
                            environment=self._env,
                            role=self._role)
 def setUp(self):
     self._scheduler = Mock()
     self._quota_checker = QuotaCheck(self._scheduler)
     self._role = "mesos"
     self._name = "quotajob"
     self._env = "test"
     self._job_key = JobKey(name=self._name, environment=self._env, role=self._role)
 def setUp(self):
   self._scheduler = Mock()
   self._quota_checker = QuotaCheck(self._scheduler)
   self._role = 'mesos'
   self._name = 'quotajob'
   self._env = 'test'
   self._job_key = JobKey(name=self._name, environment=self._env, role=self._role)
class QuotaCheckTest(unittest.TestCase):
    def setUp(self):
        self._scheduler = Mock()
        self._quota_checker = QuotaCheck(self._scheduler)
        self._role = "mesos"
        self._name = "quotajob"
        self._env = "test"
        self._job_key = JobKey(name=self._name, environment=self._env, role=self._role)

    def mock_get_quota(self, allocated, consumed, response_code=None):
        response_code = ResponseCode.OK if response_code is None else response_code

        resp = Response(responseCode=response_code, messageDEPRECATED="test")
        resp.result = Result(
            getQuotaResult=GetQuotaResult(quota=deepcopy(allocated), prodConsumption=deepcopy(consumed))
        )
        self._scheduler.getQuota.return_value = resp

    def assert_result(self, prod, released, acquired, expected_code=None):
        expected_code = ResponseCode.OK if expected_code is None else expected_code
        resp = self._quota_checker.validate_quota_from_requested(self._job_key, prod, released, acquired)
        assert expected_code == resp.responseCode, "Expected response:%s Actual response:%s" % (
            expected_code,
            resp.responseCode,
        )
        if prod:
            self._scheduler.getQuota.assert_called_once_with(self._role)
        else:
            assert not self._scheduler.getQuota.called, "Scheduler.getQuota() unexpected call."

    def test_pass(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired)

    def test_pass_with_no_consumed(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, None)
        self.assert_result(True, released, acquired)

    def test_pass_due_to_released(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=45.0, ramMb=900, diskMb=2900)
        released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
        acquired = CapacityRequest(ResourceAggregate(numCpus=10.0, ramMb=200, diskMb=200))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired)

    def test_skipped(self):
        self.assert_result(False, None, None)

    def test_fail(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(ResourceAggregate(numCpus=35.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired, ResponseCode.INVALID_REQUEST)

    def test_fail_scheduler_call(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(ResourceAggregate(numCpus=1.0, ramMb=100, diskMb=100))

        self.mock_get_quota(allocated, consumed, response_code=ResponseCode.INVALID_REQUEST)
        self.assert_result(True, released, acquired, ResponseCode.INVALID_REQUEST)
Esempio n. 6
0
class QuotaCheckTest(unittest.TestCase):
  def setUp(self):
    self._scheduler = create_autospec(spec=SchedulerThriftApiSpec, instance=True)
    self._quota_checker = QuotaCheck(self._scheduler)
    self._role = 'mesos'
    self._name = 'quotajob'
    self._env = 'test'
    self._job_key = JobKey(name=self._name, environment=self._env, role=self._role)

  def mock_get_quota(self, allocated, consumed, response_code=None):
    response_code = ResponseCode.OK if response_code is None else response_code

    resp = Response(responseCode=response_code, details=[ResponseDetail(message='test')])
    resp.result = Result(
        getQuotaResult=GetQuotaResult(
          quota=deepcopy(allocated), prodSharedConsumption=deepcopy(consumed)))
    self._scheduler.getQuota.return_value = resp

  def assert_result(self, prod, released, acquired, expected_code=None):
    expected_code = ResponseCode.OK if expected_code is None else expected_code
    resp = self._quota_checker.validate_quota_from_requested(
        self._job_key,
        prod,
        released,
        acquired)
    assert expected_code == resp.responseCode, (
      'Expected response:%s Actual response:%s' % (expected_code, resp.responseCode))
    if prod:
      self._scheduler.getQuota.assert_called_once_with(self._role)
    else:
      assert not self._scheduler.getQuota.called, 'Scheduler.getQuota() unexpected call.'

  def test_pass(self):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
    acquired = CapacityRequest(ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

    self.mock_get_quota(allocated, consumed)
    self.assert_result(True, released, acquired)

  def test_pass_with_no_consumed(self):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
    acquired = CapacityRequest(ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

    self.mock_get_quota(allocated, None)
    self.assert_result(True, released, acquired)

  def test_pass_due_to_released(self):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    consumed = ResourceAggregate(numCpus=45.0, ramMb=900, diskMb=2900)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
    acquired = CapacityRequest(ResourceAggregate(numCpus=10.0, ramMb=200, diskMb=200))

    self.mock_get_quota(allocated, consumed)
    self.assert_result(True, released, acquired)

  def test_skipped(self):
    self.assert_result(False, None, None)

  def test_fail(self):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
    acquired = CapacityRequest(ResourceAggregate(numCpus=35.0, ramMb=300, diskMb=800))

    self.mock_get_quota(allocated, consumed)
    self.assert_result(True, released, acquired, ResponseCode.INVALID_REQUEST)

  def test_fail_scheduler_call(self):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
    acquired = CapacityRequest(ResourceAggregate(numCpus=1.0, ramMb=100, diskMb=100))

    self.mock_get_quota(allocated, consumed, response_code=ResponseCode.INVALID_REQUEST)
    self.assert_result(True, released, acquired, ResponseCode.INVALID_REQUEST)

  @patch('apache.aurora.client.api.quota_check.print_quota', spec=print_quota)
  def test_additional_quota_out(self, mock_print_quota):
    allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
    consumed = ResourceAggregate(numCpus=45.0, ramMb=900, diskMb=2900)
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
    acquired = CapacityRequest(ResourceAggregate(numCpus=11.0, ramMb=220, diskMb=200))
    additional = ResourceAggregate(numCpus=1.0, ramMb=20, diskMb=0)

    self.mock_get_quota(allocated, consumed)
    self.assert_result(True, released, acquired, ResponseCode.INVALID_REQUEST)
    assert mock_print_quota.mock_calls[:4] == [
        call(allocated, 'Total allocated quota', self._role),
        call(consumed, 'Consumed quota', self._role),
        call((acquired - released).quota(), 'Requested', self._name),
        call(additional, 'Additional quota required', self._role)
    ]

  def test_op_not_cap_request(self):
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
    # Should return self so a noop.
    out = released._op('not_a_real_op', 'not_a_CapacityRequest_obj')
    self.assertEqual(out, released)

  def test_right_add(self):
    released = CapacityRequest(ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
    # Testing __radd__ which is called when object on the ride side isn't our CapacityRequest
    # instance.
    out = 1 + released
    self.assertEqual(out, released)
Esempio n. 7
0
class QuotaCheckTest(unittest.TestCase):
    def setUp(self):
        self._scheduler = Mock()
        self._quota_checker = QuotaCheck(self._scheduler)
        self._role = 'mesos'
        self._name = 'quotajob'
        self._env = 'test'
        self._job_key = JobKey(name=self._name,
                               environment=self._env,
                               role=self._role)

    def mock_get_quota(self, allocated, consumed, response_code=None):
        response_code = ResponseCode.OK if response_code is None else response_code

        resp = Response(responseCode=response_code, messageDEPRECATED='test')
        resp.result = Result(getQuotaResult=GetQuotaResult(
            quota=deepcopy(allocated), prodConsumption=deepcopy(consumed)))
        self._scheduler.getQuota.return_value = resp

    def assert_result(self, prod, released, acquired, expected_code=None):
        expected_code = ResponseCode.OK if expected_code is None else expected_code
        resp = self._quota_checker.validate_quota_from_requested(
            self._job_key, prod, released, acquired)
        assert expected_code == resp.responseCode, (
            'Expected response:%s Actual response:%s' %
            (expected_code, resp.responseCode))
        if prod:
            self._scheduler.getQuota.assert_called_once_with(self._role)
        else:
            assert not self._scheduler.getQuota.called, 'Scheduler.getQuota() unexpected call.'

    def test_pass(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(
            ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(
            ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired)

    def test_pass_with_no_consumed(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        released = CapacityRequest(
            ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(
            ResourceAggregate(numCpus=15.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, None)
        self.assert_result(True, released, acquired)

    def test_pass_due_to_released(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=45.0, ramMb=900, diskMb=2900)
        released = CapacityRequest(
            ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=100))
        acquired = CapacityRequest(
            ResourceAggregate(numCpus=10.0, ramMb=200, diskMb=200))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired)

    def test_skipped(self):
        self.assert_result(False, None, None)

    def test_fail(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(
            ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(
            ResourceAggregate(numCpus=35.0, ramMb=300, diskMb=800))

        self.mock_get_quota(allocated, consumed)
        self.assert_result(True, released, acquired,
                           ResponseCode.INVALID_REQUEST)

    def test_fail_scheduler_call(self):
        allocated = ResourceAggregate(numCpus=50.0, ramMb=1000, diskMb=3000)
        consumed = ResourceAggregate(numCpus=25.0, ramMb=500, diskMb=2000)
        released = CapacityRequest(
            ResourceAggregate(numCpus=5.0, ramMb=100, diskMb=500))
        acquired = CapacityRequest(
            ResourceAggregate(numCpus=1.0, ramMb=100, diskMb=100))

        self.mock_get_quota(allocated,
                            consumed,
                            response_code=ResponseCode.INVALID_REQUEST)
        self.assert_result(True, released, acquired,
                           ResponseCode.INVALID_REQUEST)