SqMod/vendor/ZMQ/tests/test_req_relaxed.cpp

/* SPDX-License-Identifier: MPL-2.0 */

#include "testutil.hpp"
#include "testutil_unity.hpp"

#include <unity.h>

const size_t services = 5;

void *req;
void *rep[services];

void setUp ()
{
    setup_test_context ();

    char my_endpoint[MAX_SOCKET_STRING];
    req = test_context_socket (ZMQ_REQ);

    int enabled = 1;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));

    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));

    bind_loopback_ipv4 (req, my_endpoint, sizeof (my_endpoint));

    for (size_t peer = 0; peer < services; peer++) {
        rep[peer] = test_context_socket (ZMQ_REP);

        TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rep[peer], my_endpoint));

        //  These tests require strict ordering, so wait for the connections to
        //  happen before opening the next, so that messages flow in the
        //  expected direction
        msleep (SETTLE_TIME);
    }
}

void tearDown ()
{
    test_context_socket_close_zero_linger (req);
    for (size_t peer = 0; peer < services; peer++)
        test_context_socket_close_zero_linger (rep[peer]);

    teardown_test_context ();
}

static void bounce (void *socket_)
{
    int more;
    size_t more_size = sizeof (more);
    do {
        zmq_msg_t recv_part, sent_part;
        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&recv_part));

        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&recv_part, socket_, 0));

        TEST_ASSERT_SUCCESS_ERRNO (
          zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size));

        zmq_msg_init (&sent_part);
        zmq_msg_copy (&sent_part, &recv_part);

        TEST_ASSERT_SUCCESS_ERRNO (
          zmq_msg_send (&sent_part, socket_, more ? ZMQ_SNDMORE : 0));

        zmq_msg_close (&recv_part);
    } while (more);
}

static int get_events (void *socket_)
{
    int events;
    size_t events_size = sizeof (events);
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_getsockopt (socket_, ZMQ_EVENTS, &events, &events_size));
    return events;
}

void test_case_1 ()
{
    //  Case 1: Second send() before a reply arrives in a pipe.

    int events = get_events (req);
    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);

    //  Send a request, ensure it arrives, don't send a reply
    s_send_seq (req, "A", "B", SEQ_END);
    s_recv_seq (rep[0], "A", "B", SEQ_END);

    events = get_events (req);
    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);

    //  Send another request on the REQ socket
    s_send_seq (req, "C", "D", SEQ_END);
    s_recv_seq (rep[1], "C", "D", SEQ_END);

    events = get_events (req);
    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);

    //  Send a reply to the first request - that should be discarded by the REQ
    s_send_seq (rep[0], "WRONG", SEQ_END);

    //  Send the expected reply
    s_send_seq (rep[1], "OK", SEQ_END);
    s_recv_seq (req, "OK", SEQ_END);

    //  Another standard req-rep cycle, just to check
    s_send_seq (req, "E", SEQ_END);
    s_recv_seq (rep[2], "E", SEQ_END);
    s_send_seq (rep[2], "F", "G", SEQ_END);
    s_recv_seq (req, "F", "G", SEQ_END);
}

void test_case_2 ()
{
    //  Case 2: Second send() after a reply is already in a pipe on the REQ.

    // TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
    test_case_1 ();

    //  Send a request, ensure it arrives, send a reply
    s_send_seq (req, "H", SEQ_END);
    s_recv_seq (rep[3], "H", SEQ_END);
    s_send_seq (rep[3], "BAD", SEQ_END);

    //  Wait for message to be there.
    msleep (SETTLE_TIME);

    //  Without receiving that reply, send another request on the REQ socket
    s_send_seq (req, "I", SEQ_END);
    s_recv_seq (rep[4], "I", SEQ_END);

    //  Send the expected reply
    s_send_seq (rep[4], "GOOD", SEQ_END);
    s_recv_seq (req, "GOOD", SEQ_END);
}

void test_case_3 ()
{
    //  Case 3: Check issue #1690. Two send() in a row should not close the
    //  communication pipes. For example pipe from req to rep[0] should not be
    //  closed after executing Case 1. So rep[0] should be the next to receive,
    //  not rep[1].

    // TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
    test_case_2 ();

    s_send_seq (req, "J", SEQ_END);
    s_recv_seq (rep[0], "J", SEQ_END);
}

void test_case_4 ()
{
    // TODO this test case does not use the sockets from setUp

    //  Case 4: Check issue #1695. As messages may pile up before a responder
    //  is available, we check that responses to messages other than the last
    //  sent one are correctly discarded by the REQ pipe

    //  Setup REQ socket as client
    void *req = test_context_socket (ZMQ_REQ);

    int enabled = 1;
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));
    TEST_ASSERT_SUCCESS_ERRNO (
      zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));

    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (req, ENDPOINT_0));

    //  Setup ROUTER socket as server but do not bind it just yet
    void *router = test_context_socket (ZMQ_ROUTER);

    //  Send two requests
    s_send_seq (req, "TO_BE_DISCARDED", SEQ_END);
    s_send_seq (req, "TO_BE_ANSWERED", SEQ_END);

    //  Bind server allowing it to receive messages
    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (router, ENDPOINT_0));

    //  Read the two messages and send them back as is
    bounce (router);
    bounce (router);

    //  Read the expected correlated reply. As the ZMQ_REQ_CORRELATE is active,
    //  the expected answer is "TO_BE_ANSWERED", not "TO_BE_DISCARDED".
    s_recv_seq (req, "TO_BE_ANSWERED", SEQ_END);

    test_context_socket_close_zero_linger (req);
    test_context_socket_close_zero_linger (router);
}

int main ()
{
    setup_test_environment ();

    UNITY_BEGIN ();
    RUN_TEST (test_case_1);
    RUN_TEST (test_case_2);
    RUN_TEST (test_case_3);
    RUN_TEST (test_case_4);
    return UNITY_END ();
}