def test_all_retries(self):
"""
If bulk_delete returns "server not a member", lb or server deleted
for all attempted pairs then there is no retry and returns None
"""
errors = {
"errors": [
server_not_member(self.lbs[0].upper(), self.nodes[0]),
"Cloud Server {} does not exist".format(self.nodes[1]),
"Load Balancer Pool {} does not exist".format(
self.lbs[2].upper())
]
}
pairs = pset([
(self.lbs[0], self.nodes[1]), # test same server pairs
(self.lbs[2], self.nodes[0]) # test same lb pairs
])
pairs = self.pairs | pairs
data = r._sorted_data(pairs)
seq = [
(self.svc_req_intent(data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors, req_body=("jsonified", data)),
noop)
]
self.assertIsNone(perform_sequence(seq, r.bulk_delete(pairs)))
def test_all_retries(self):
"""
If bulk_delete returns "server not a member", lb or server deleted
for all attempted pairs then there is no retry and returns None
"""
errors = {
"errors": [
server_not_member(self.lbs[0].upper(), self.nodes[0]),
"Cloud Server {} does not exist".format(self.nodes[1]),
"Load Balancer Pool {} does not exist".format(
self.lbs[2].upper())
]
}
pairs = pset([
(self.lbs[0], self.nodes[1]), # test same server pairs
(self.lbs[2], self.nodes[0]) # test same lb pairs
])
pairs = self.pairs | pairs
data = r._sorted_data(pairs)
seq = [(self.svc_req_intent(data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", data)), noop)]
self.assertIsNone(perform_sequence(seq, r.bulk_delete(pairs)))
def _check_retries(self, get_pairs_data):
errors = {
"errors": [
server_not_member(self.lbs[0].upper(), self.nodes[0]),
"Cloud Server {} does not exist".format(self.nodes[1]),
"Load Balancer Pool {} does not exist".format(
self.lbs[2].upper())
]
}
lbr1 = "d6d3aa7c-dfa5-4e61-96ee-1d54ac1075d2"
noder1 = "a95ae0c4-6ab8-4873-b82f-f8433840cff2"
lbr2 = "e6d3aa7c-dfa5-4e61-96ee-1d54ac1075d2"
noder2 = "e95ae0c4-6ab8-4873-b82f-f8433840cff2"
pairs, data = get_pairs_data(lbr1, noder1, lbr2, noder2)
retried_data = r._sorted_data([(lbr1, noder1), (lbr2, noder2)])
success_resp = {"good": "response"}
seq = [
(self.svc_req_intent(data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors, req_body=("jsonified", data)),
noop),
(self.svc_req_intent(retried_data),
const(stub_json_response(success_resp, 204))),
(log_intent(
"request-rcv3-bulk", success_resp,
req_body=("jsonified", retried_data)),
noop)
]
self.assertEqual(
perform_sequence(seq, r.bulk_delete(pairs)), success_resp)
def _check_retries(self, get_pairs_data):
errors = {
"errors": [
server_not_member(self.lbs[0].upper(), self.nodes[0]),
"Cloud Server {} does not exist".format(self.nodes[1]),
"Load Balancer Pool {} does not exist".format(
self.lbs[2].upper())
]
}
lbr1 = "d6d3aa7c-dfa5-4e61-96ee-1d54ac1075d2"
noder1 = "a95ae0c4-6ab8-4873-b82f-f8433840cff2"
lbr2 = "e6d3aa7c-dfa5-4e61-96ee-1d54ac1075d2"
noder2 = "e95ae0c4-6ab8-4873-b82f-f8433840cff2"
pairs, data = get_pairs_data(lbr1, noder1, lbr2, noder2)
retried_data = r._sorted_data([(lbr1, noder1), (lbr2, noder2)])
success_resp = {"good": "response"}
seq = [(self.svc_req_intent(data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", data)), noop),
(self.svc_req_intent(retried_data),
const(stub_json_response(success_resp, 204))),
(log_intent("request-rcv3-bulk",
success_resp,
req_body=("jsonified", retried_data)), noop)]
self.assertEqual(perform_sequence(seq, r.bulk_delete(pairs)),
success_resp)
def as_effect(self):
"""
Produce a :obj:`Effect` to remove some nodes from some RCv3 load
balancers.
"""
eff = rcv3.bulk_delete(self.lb_node_pairs)
return eff.on(
success=lambda _: (StepResult.RETRY, [ErrorReason.String(
'must re-gather after RCv3 LB change in order to update the '
'active cache')]),
error=_failure_reporter(rcv3.BulkErrors))
def test_success(self):
"""
bulk_delete resulting in 204 returns Effect of None
"""
resp = {"response": "yo!"}
seq = [(self.svc_req_intent(self.data),
const(stub_json_response(resp, 204))),
(log_intent("request-rcv3-bulk",
resp,
req_body=("jsonified", self.data)), noop)]
self.assertEqual(perform_sequence(seq, r.bulk_delete(self.pairs)),
resp)
def as_effect(self):
"""
Produce a :obj:`Effect` to remove some nodes from some RCv3 load
balancers.
"""
eff = rcv3.bulk_delete(self.lb_node_pairs)
return eff.on(success=lambda _: (StepResult.RETRY, [
ErrorReason.String(
'must re-gather after RCv3 LB change in order to update the '
'active cache')
]),
error=_failure_reporter(rcv3.BulkErrors))
def test_empty_errors(self):
"""
If bulk_delete returns 409 with empty errors then `UnknownBulkResponse`
is raised
"""
errors = {"errors": []}
seq = [(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", self.data)), noop)]
self.assertRaises(r.UnknownBulkResponse, perform_sequence, seq,
r.bulk_delete(self.pairs))
def test_unknown_errors(self):
"""
If any of the errors returned with 409 are unknown then
`UnknownBulkResponse` is raised
"""
errors = {"errors": ["unknown error", lb_inactive(self.lbs[0])]}
seq = [(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", self.data)), noop)]
self.assertRaises(r.UnknownBulkResponse, perform_sequence, seq,
r.bulk_delete(self.pairs))
def test_success(self):
"""
bulk_delete resulting in 204 returns Effect of None
"""
resp = {"response": "yo!"}
seq = [
(self.svc_req_intent(self.data),
const(stub_json_response(resp, 204))),
(log_intent(
"request-rcv3-bulk", resp, req_body=("jsonified", self.data)),
noop)
]
self.assertEqual(
perform_sequence(seq, r.bulk_delete(self.pairs)), resp)
def test_empty_errors(self):
"""
If bulk_delete returns 409 with empty errors then `UnknownBulkResponse`
is raised
"""
errors = {"errors": []}
seq = [
(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors,
req_body=("jsonified", self.data)),
noop)
]
self.assertRaises(
r.UnknownBulkResponse, perform_sequence, seq,
r.bulk_delete(self.pairs))
def test_lb_inactive(self):
"""
If bulk_delete returns 409 with only LB inactive errors then it raises
`BulkErrors` with LBInActive errors in it
"""
errors = {
"errors": [lb_inactive(self.lbs[0]),
lb_inactive(self.lbs[1])]
}
seq = [(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", self.data)), noop)]
with self.assertRaises(r.BulkErrors) as ec:
perform_sequence(seq, r.bulk_delete(self.pairs))
self.assertEqual(
ec.exception.errors,
pset([r.LBInactive(self.lbs[0]),
r.LBInactive(self.lbs[1])]))
def test_lb_inactive_and_retry_error(self):
"""
If bulk_delete returns lb inactive along with any other errors then
there is no retry and BulkErrors is raised
"""
errors = {
"errors": [
lb_inactive(self.lbs[0]),
server_not_member(self.lbs[1], self.nodes[1]),
server_not_member(self.lbs[1].upper(), self.nodes[1])
]
}
seq = [(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent("request-rcv3-bulk",
errors,
req_body=("jsonified", self.data)), noop)]
with self.assertRaises(r.BulkErrors) as ec:
perform_sequence(seq, r.bulk_delete(self.pairs))
self.assertEqual(ec.exception.errors,
pset([r.LBInactive(self.lbs[0])]))
def test_unknown_errors(self):
"""
If any of the errors returned with 409 are unknown then
`UnknownBulkResponse` is raised
"""
errors = {
"errors": [
"unknown error",
lb_inactive(self.lbs[0])
]
}
seq = [
(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors,
req_body=("jsonified", self.data)),
noop)
]
self.assertRaises(
r.UnknownBulkResponse, perform_sequence, seq,
r.bulk_delete(self.pairs))
def test_lb_inactive_and_retry_error(self):
"""
If bulk_delete returns lb inactive along with any other errors then
there is no retry and BulkErrors is raised
"""
errors = {
"errors": [
lb_inactive(self.lbs[0]),
server_not_member(self.lbs[1], self.nodes[1]),
server_not_member(self.lbs[1].upper(), self.nodes[1])
]
}
seq = [
(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors,
req_body=("jsonified", self.data)),
noop)
]
with self.assertRaises(r.BulkErrors) as ec:
perform_sequence(seq, r.bulk_delete(self.pairs))
self.assertEqual(
ec.exception.errors, pset([r.LBInactive(self.lbs[0])]))
def test_lb_inactive(self):
"""
If bulk_delete returns 409 with only LB inactive errors then it raises
`BulkErrors` with LBInActive errors in it
"""
errors = {
"errors": [
lb_inactive(self.lbs[0]), lb_inactive(self.lbs[1])
]
}
seq = [
(self.svc_req_intent(self.data),
const(stub_json_response(errors, 409))),
(log_intent(
"request-rcv3-bulk", errors,
req_body=("jsonified", self.data)),
noop)
]
with self.assertRaises(r.BulkErrors) as ec:
perform_sequence(seq, r.bulk_delete(self.pairs))
self.assertEqual(
ec.exception.errors,
pset([r.LBInactive(self.lbs[0]), r.LBInactive(self.lbs[1])])
)
