blockstream-satellite-api/server/tests/test_orders.py

import random
from datetime import datetime, timedelta
from http import HTTPStatus
from math import ceil, floor
from unittest.mock import patch

import pytest

from constants import InvoiceStatus, OrderStatus, ORDER_FETCH_STATES
from database import db
from models import Order, TxRetry
import constants
import server

from common import new_invoice, place_order, generate_test_order
from error import assert_error


def place_orders(client,
                 mock_new_invoice,
                 n_orders,
                 n_bytes,
                 target_state='pending',
                 channel=1,
                 admin=False):
    # target_state refers to one of the order fetching states accepted by the
    # /orders/:state endpoint. Set the target order status based on that.
    if target_state in ['queued', 'retransmitting']:
        order_status = OrderStatus.transmitting.value
    elif target_state == 'rx-pending':
        order_status = OrderStatus.sent.value
    else:
        order_status = OrderStatus[target_state].value

    order_list = []
    for i in range(n_orders):
        # Randomize the bid
        bid_per_byte = random.randint(1, 10000)
        bid = bid_per_byte * n_bytes

        # Randomize the relevant timestamps
        tstamp = datetime.utcnow() - timedelta(
            seconds=random.randint(1, 10000))

        mock_new_invoice.return_value = (True,
                                         new_invoice(1, InvoiceStatus.pending,
                                                     bid))

        post_rv = place_order(client,
                              n_bytes,
                              bid=bid,
                              channel=channel,
                              admin=admin)
        assert post_rv.status_code == HTTPStatus.OK
        uuid = post_rv.get_json()['uuid']

        # Set the status and the fields required in each status
        db_order = Order.query.filter_by(uuid=uuid).first()
        db_order.created_at = tstamp
        db_order.status = order_status
        if target_state in ['transmitting', 'confirming', 'retransmitting']:
            db_order.started_transmission_at = tstamp
        if target_state in ['sent', 'received', 'rx-pending']:
            db_order.ended_transmission_at = tstamp
        if target_state == 'retransmitting':
            new_retry_tx = TxRetry(order_id=db_order.id,
                                   region_code=0,
                                   last_attempt=tstamp)
            db.session.add(new_retry_tx)
        db.session.commit()
        order_list.append(db_order)
    return order_list


@pytest.fixture
def client(mockredis):
    app = server.create_app(from_test=True)
    app.app_context().push()
    with app.test_client() as client:
        yield client
    server.teardown_app(app)


@pytest.mark.parametrize("param", ['before', 'after'])
def test_get_orders_invalid_before_after_parameter(client, param):
    for tstamp in [
            '', '2021-13-11', '2021.05.10', '2021-05-1a0T19:51:45',
            '2021.05.10T19:51:45', '2021-05-10T25:51:45'
    ]:
        get_rv = client.get(f'/orders/pending?{param}={tstamp}')
        assert get_rv.status_code == HTTPStatus.BAD_REQUEST
        assert f'{param}' in get_rv.get_json()

    get_rv = client.get(f'/orders/pending?{param}=2021-05-10T22:51:45')
    assert get_rv.status_code == HTTPStatus.OK
    # before and before_delta together should not be allowed. Same for after
    # and after_delta.
    get_rv = client.get(
        f'/orders/pending?{param}=2021-05-10T22:51:45&{param}_delta=5')
    assert get_rv.status_code == HTTPStatus.BAD_REQUEST


@pytest.mark.parametrize("param", ['before', 'after'])
def test_get_orders_invalid_before_after_delta_parameter(client, param):
    for delta in ['', 'sometext', '2021-05-10T25:51:45', '5.2']:
        get_rv = client.get(f'/orders/pending?{param}_delta={delta}')
        assert get_rv.status_code == HTTPStatus.BAD_REQUEST
        assert f'{param}_delta' in get_rv.get_json()

    get_rv = client.get(f'/orders/pending?{param}_delta=5')
    assert get_rv.status_code == HTTPStatus.OK
    # before and before_delta together should not be allowed. Same for after
    # and after_delta.
    get_rv = client.get(
        f'/orders/pending?{param}_delta=5&{param}=2021-05-10T22:51:45')
    assert get_rv.status_code == HTTPStatus.BAD_REQUEST


def test_get_orders_invalid_limit(client):
    for limit in [
            '',
            'sometext',
            '1a2',
            '-1',
            '1.2',
            constants.MAX_PAGE_SIZE + 1,
    ]:
        get_rv = client.get(f'/orders/pending?limit={limit}')
        assert get_rv.status_code == HTTPStatus.BAD_REQUEST
        assert 'limit' in get_rv.get_json()

    get_rv = client.get('/orders/pending?limit=1')
    assert get_rv.status_code == HTTPStatus.OK
    get_rv = client.get(f'/orders/pending?limit={constants.MAX_PAGE_SIZE}')
    assert get_rv.status_code == HTTPStatus.OK


def test_try_to_get_invalid_order_state(client):
    for state in ['pendiing', 'someendpoint', 'Pending']:
        get_rv = client.get(f'/orders/{state}')
        assert get_rv.status_code == HTTPStatus.NOT_FOUND


@patch('constants.PAGE_SIZE', 3)  # change PAGE_SIZE to run this test faster
@patch('orders.new_invoice')
@pytest.mark.parametrize("state", ORDER_FETCH_STATES)
def test_get_orders_date_filtering_parameters(mock_new_invoice, client, state):
    # Create PAGE_SIZE orders with random timestamps
    n_bytes = 500
    n_orders = constants.PAGE_SIZE
    order_list = place_orders(client, mock_new_invoice, n_orders, n_bytes,
                              state)
    sorted_orders = sorted(order_list,
                           key=lambda x: x.created_at,
                           reverse=True)
    order_uuids = [x.uuid for x in sorted_orders]
    order_creation_timestamps = sorted([x.created_at for x in order_list],
                                       reverse=True)

    # Fetch orders excluding the most recent
    uuid_set1 = set(order_uuids[1:])
    before = order_creation_timestamps[0].isoformat()
    get_rv = client.get(f'/orders/{state}?before={before}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set1

    # Fetch orders excluding the oldest
    uuid_set2 = set(order_uuids[:-1])
    after = order_creation_timestamps[-1].isoformat()
    get_rv = client.get(f'/orders/{state}?after={after}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set2

    # Fetch the two orders in the middle
    uuid_set3 = set(order_uuids[1:-1])
    get_rv = client.get(f'/orders/{state}?after={after}&before={before}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set3

    # Try the same using the delta parameters

    # Fetch orders excluding the most recent
    delta_to_most_recent = datetime.utcnow() - order_creation_timestamps[0]
    before_delta = ceil(delta_to_most_recent.total_seconds()) + 1
    get_rv = client.get(f'/orders/{state}?before_delta={before_delta}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set1

    # Fetch orders excluding the oldest
    delta_to_oldest = datetime.utcnow() - order_creation_timestamps[-1]
    after_delta = floor(delta_to_oldest.total_seconds()) - 1
    get_rv = client.get(f'/orders/{state}?after_delta={after_delta}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set2

    # Fetch the two orders in the middle
    get_rv = client.get(f'/orders/{state}?after_delta={after_delta}&' +
                        f'before_delta={before_delta}')
    assert get_rv.status_code == HTTPStatus.OK
    assert set([x['uuid'] for x in get_rv.get_json()]) == uuid_set3


@patch('orders.new_invoice')
@pytest.mark.parametrize("state", ['pending', 'retransmitting'])
def test_get_orders_limit_parameter(mock_new_invoice, client, state):
    n_bytes = 500
    n_orders = constants.PAGE_SIZE + 1
    place_orders(client, mock_new_invoice, n_orders, n_bytes, state)

    # no limit parameter, max PAGE_SIZE should be returned
    get_rv = client.get(f'/orders/{state}')
    assert get_rv.status_code == HTTPStatus.OK
    get_json_resp = get_rv.get_json()
    assert len(get_json_resp) == constants.PAGE_SIZE

    # with limit parameter present
    get_rv = client.get(f'/orders/{state}?limit=10')
    assert get_rv.status_code == HTTPStatus.OK
    get_json_resp = get_rv.get_json()
    assert len(get_json_resp) == 10


@patch('constants.PAGE_SIZE', 3)  # change PAGE_SIZE to run this test faster
@patch('orders.new_invoice')
@pytest.mark.parametrize("state", ORDER_FETCH_STATES)
@pytest.mark.parametrize("channel", constants.CHANNELS)
def test_get_orders_by_channel(mock_new_invoice, client, state, channel):
    n_bytes = 500
    n_orders = constants.PAGE_SIZE + 1
    place_orders(client,
                 mock_new_invoice,
                 n_orders,
                 n_bytes,
                 state,
                 channel=channel,
                 admin=True)

    # Get the orders of each channel as a regular user
    for _channel in constants.CHANNELS:
        get_rv = client.get(f'/orders/{state}?channel={_channel}')
        if 'get' in constants.CHANNEL_INFO[_channel].user_permissions:
            assert get_rv.status_code == HTTPStatus.OK
            get_json_resp = get_rv.get_json()
            n_expected_res = constants.PAGE_SIZE if _channel == channel else 0
            assert len(get_json_resp) == n_expected_res
        else:
            assert get_rv.status_code == HTTPStatus.UNAUTHORIZED
            assert_error(get_rv.get_json(), 'ORDER_CHANNEL_UNAUTHORIZED_OP')

    # Get the orders of each channel as an admin user
    for _channel in constants.CHANNELS:
        get_rv = client.get(f'/admin/orders/{state}?channel={_channel}')
        assert get_rv.status_code == HTTPStatus.OK
        get_json_resp = get_rv.get_json()
        n_expected_res = constants.PAGE_SIZE if _channel == channel else 0
        assert len(get_json_resp) == n_expected_res


@patch('orders.new_invoice')
@patch('constants.PAGE_SIZE', 3)  # change PAGE_SIZE to run this test faster
def test_get_orders_paging(mock_new_invoice, client):
    # make more orders than PAGE_SIZE
    n_orders = constants.PAGE_SIZE + 2
    n_bytes = 500
    order_list = place_orders(client, mock_new_invoice, n_orders, n_bytes)
    sorted_orders = sorted(order_list,
                           key=lambda x: x.created_at,
                           reverse=True)
    order_uuids = [x.uuid for x in sorted_orders]

    # Check all orders were created
    all_orders = Order.query.filter_by(status=OrderStatus.pending.value).all()
    assert len(all_orders) == n_orders

    # Fetch the pending orders with paging
    get_rv = client.get('/orders/pending')
    assert get_rv.status_code == HTTPStatus.OK
    resp_uuids = [x['uuid'] for x in get_rv.get_json()]

    # Only the last PAGE_SIZE orders should be returned
    assert len(resp_uuids) == constants.PAGE_SIZE
    assert resp_uuids == order_uuids[:constants.PAGE_SIZE]


@patch('orders.new_invoice')
@pytest.mark.parametrize("queue", ['queued', 'sent'])
def test_get_orders_multi_state_queues(mock_new_invoice, client, queue):
    """Test queues that return orders in multiple state"""
    # Create some orders with different states
    order_dict = {}
    for state in [
            'pending', 'paid', 'transmitting', 'sent', 'received', 'confirming'
    ]:
        order_dict[state] = generate_test_order(
            mock_new_invoice, client, order_status=OrderStatus[state])
        if state in ['sent', 'received']:
            db_order = Order.query.filter_by(
                uuid=order_dict[state]['uuid']).first()
            db_order.ended_transmission_at = datetime.utcnow()
            db.session.commit()

    # Fetch the orders from the chosen queue
    get_rv = client.get(f'/orders/{queue}')
    assert get_rv.status_code == HTTPStatus.OK
    queued_uuids = [order['uuid'] for order in get_rv.get_json()]

    # Status that can be expected in the chosen queue
    expected_status = {
        'queued': ['paid', 'transmitting', 'confirming'],
        'sent': ['sent', 'received']
    }

    for state in order_dict:
        if state in expected_status[queue]:
            assert order_dict[state]['uuid'] in queued_uuids
        else:
            assert order_dict[state]['uuid'] not in queued_uuids


@patch('orders.new_invoice')
@pytest.mark.parametrize("state", ORDER_FETCH_STATES)
def test_get_orders_sorting(mock_new_invoice, client, state):
    n_bytes = 500
    n_orders = 10
    order_list = place_orders(client, mock_new_invoice, n_orders, n_bytes,
                              state)

    if state in ['pending', 'paid']:
        # sorted by created_at
        expected_sorted_orders = sorted(order_list,
                                        key=lambda x: x.created_at,
                                        reverse=True)
    elif state in ['transmitting', 'confirming', 'retransmitting']:
        # sorted by started_transmission_at
        expected_sorted_orders = sorted(
            order_list, key=lambda x: x.started_transmission_at, reverse=True)
    elif state in ['sent', 'received', 'rx-pending']:
        # sorted by ended_transmission_at
        expected_sorted_orders = sorted(order_list,
                                        key=lambda x: x.ended_transmission_at,
                                        reverse=True)
    elif state == 'queued':
        # sorted by bid_per_byte
        expected_sorted_orders = sorted(order_list,
                                        key=lambda x: x.bid_per_byte,
                                        reverse=True)

    get_rv = client.get(f'/orders/{state}')
    assert get_rv.status_code == HTTPStatus.OK
    get_json_resp = get_rv.get_json()
    assert len(get_json_resp) == n_orders
    for i in range(n_orders):
        assert get_json_resp[i]['uuid'] == expected_sorted_orders[i].uuid
        assert get_json_resp[i]['bid_per_byte'] == expected_sorted_orders[
            i].bid_per_byte


@patch('orders.new_invoice')
@patch('constants.FORCE_PAYMENT', True)
def test_create_order_with_force_payment_enabled(mock_new_invoice, client):
    uuid_order1 = generate_test_order(mock_new_invoice, client)['uuid']
    uuid_order2 = generate_test_order(mock_new_invoice, client)['uuid']

    db_order1 = Order.query.filter_by(uuid=uuid_order1).first()
    db_invoice1 = db_order1.invoices[0]

    db_order2 = Order.query.filter_by(uuid=uuid_order2).first()
    db_invoice2 = db_order2.invoices[0]

    # Since FORCE_PAYMENT is set and both orders have only one invoice, both
    # orders change their statuses to paid. Furthermore, the payment triggers a
    # Tx start verification and, since the transmit queue is empty, order1
    # immediately changes to transmitting state. In contrast, order2 stays in
    # paid state as it needs to wait until the transmission of order1 finishes.
    assert db_order1.status == OrderStatus.transmitting.value
    assert db_invoice1.status == InvoiceStatus.paid.value
    assert db_invoice1.paid_at is not None

    assert db_order2.status == OrderStatus.paid.value
    assert db_invoice2.status == InvoiceStatus.paid.value
    assert db_invoice2.paid_at is not None