def test_delete_messages(make_stubber, make_queue, message_count):
    """Test that deleting a single message or a batch of messages returns
    the expected success response."""
    sqs_stubber = make_stubber(message_wrapper.sqs.meta.client)
    queue = make_queue(sqs_stubber, message_wrapper.sqs)

    body = "I'm not long for this world."
    wait_time = 1

    messages = [{'body': body, 'attributes': {}}] * message_count

    sqs_stubber.stub_send_message_batch(queue.url, messages)
    sqs_stubber.stub_receive_messages(queue.url, messages, message_count)

    message_wrapper.send_messages(queue, messages)
    messages = message_wrapper.receive_messages(queue, message_count,
                                                wait_time)

    if message_count == 1:
        sqs_stubber.stub_delete_message(queue.url, messages[0])
        messages[0].delete()
    else:
        sqs_stubber.stub_delete_message_batch(queue.url, messages,
                                              len(messages), 0)
        message_wrapper.delete_messages(queue, messages)
def test_delete_messages_not_exist(sqs_stubber, queue_stub):
    """Test that deleting a batch of messages that don't exist succeeds
    and returns the expected list of failed messages."""
    messages = [
        queue_stub.Message(receipt_handle=f'fake-handle-{ind}')
        for ind in range(0, 5)
    ]

    sqs_stubber.add_response('delete_message_batch',
                             expected_params={
                                 'QueueUrl':
                                 queue_stub.url,
                                 'Entries': [{
                                     'Id':
                                     str(ind),
                                     'ReceiptHandle':
                                     msg.receipt_handle
                                 } for ind, msg in enumerate(messages)]
                             },
                             service_response={
                                 'Successful': [],
                                 'Failed': [{
                                     'Id': str(ind),
                                     'Code': 'ReceiptHandleIsInvalid',
                                     'SenderFault': False
                                 } for ind in range(0, len(messages))]
                             })

    response = message_wrapper.delete_messages(queue_stub, messages)

    assert len(response['Failed']) == len(messages)
    assert all([
        failed['Code'] == 'ReceiptHandleIsInvalid'
        for failed in response['Failed']
    ])
def test_delete_messages_not_exist(make_stubber, make_queue):
    """Test that deleting a batch of messages that don't exist succeeds
    and returns the expected list of failed messages."""
    sqs_stubber = make_stubber(message_wrapper.sqs.meta.client)
    queue = make_queue(sqs_stubber, message_wrapper.sqs)
    messages = [
        queue.Message(receipt_handle=f'fake-handle-{ind}')
        for ind in range(0, 5)
    ]

    sqs_stubber.stub_delete_message_batch(queue.url, messages, 0, len(messages))

    response = message_wrapper.delete_messages(queue, messages)

    assert len(response['Failed']) == len(messages)
    assert all([failed['Code'] == 'ReceiptHandleIsInvalid'
                for failed in response['Failed']])
def test_delete_messages(sqs_stubber, queue_stub, message_count):
    """Test that deleting a single message or a batch of messages returns
    the expected success response."""
    body = "I'm not long for this world."
    wait_time = 1

    sqs_stubber.add_response('send_message_batch',
                             expected_params={
                                 'QueueUrl':
                                 queue_stub.url,
                                 'Entries': [{
                                     'Id': str(ind),
                                     'MessageBody': body,
                                     'MessageAttributes': {}
                                 } for ind in range(0, message_count)]
                             },
                             service_response={
                                 'Successful': [{
                                     'Id':
                                     str(ind),
                                     'MessageId':
                                     f'{ind}-1234',
                                     'MD5OfMessageBody':
                                     'Test-MD5-Body',
                                 } for ind in range(0, message_count)],
                                 'Failed': []
                             })
    sqs_stubber.add_response('receive_message',
                             expected_params={
                                 'QueueUrl': queue_stub.url,
                                 'MessageAttributeNames': ['All'],
                                 'MaxNumberOfMessages': message_count,
                                 'WaitTimeSeconds': wait_time
                             },
                             service_response={
                                 'Messages': [{
                                     'MessageId': f'{ind}-1234',
                                     'Body': body,
                                     'MD5OfBody': 'Test-MD5-Body',
                                     'ReceiptHandle': f'Receipt-{ind}'
                                 } for ind in range(0, message_count)]
                             })

    message_wrapper.send_messages(queue_stub, [{
        'body': body,
        'attributes': {}
    }] * message_count)
    messages = message_wrapper.receive_messages(queue_stub, message_count,
                                                wait_time)

    if message_count == 1:
        sqs_stubber.add_response('delete_message',
                                 expected_params={
                                     'QueueUrl': queue_stub.url,
                                     'ReceiptHandle':
                                     messages[0].receipt_handle
                                 },
                                 service_response={})

        messages[0].delete()
    else:
        sqs_stubber.add_response('delete_message_batch',
                                 expected_params={
                                     'QueueUrl':
                                     queue_stub.url,
                                     'Entries': [{
                                         'Id':
                                         str(ind),
                                         'ReceiptHandle':
                                         msg.receipt_handle
                                     } for ind, msg in enumerate(messages)]
                                 },
                                 service_response={
                                     'Successful': [{
                                         'Id': str(ind)
                                     } for ind in range(0, message_count)],
                                     'Failed': []
                                 })

        message_wrapper.delete_messages(queue_stub, messages)