test-tool: add iSCSI SendTargets.Invalid test case

This test sends a series of Text request PDUs with key-value data that
doesn't match SendTargets=All.

Signed-off-by: David Disseldorp <ddiss@suse.de>

test-tool/iscsi-test-cu.c

@@ -560,6 +560,7 @@ static CU_TestInfo tests_iscsi_datasn[] = {
 
 static CU_TestInfo tests_iscsi_sendtargets[] = {
         { (char *)"Simple", test_iscsi_sendtargets_simple },
+        { (char *)"Invalid", test_iscsi_sendtargets_invalid },
         CU_TEST_INFO_NULL
 };
 

test-tool/iscsi-test-cu.h

@@ -79,6 +79,7 @@ void test_iscsi_cmdsn_toolow(void);
 
 void test_iscsi_datasn_invalid(void);
 void test_iscsi_sendtargets_simple(void);
+void test_iscsi_sendtargets_invalid(void);
 
 void test_mandatory_sbc(void);
 

test-tool/test_iscsi_sendtargets.c

@@ -17,6 +17,7 @@
 */
 
 #include <stdio.h>
+#include <stdbool.h>
 #include <arpa/inet.h>
 #include <CUnit/CUnit.h>
 #include <poll.h>
@@ -29,6 +30,9 @@
 struct test_iscsi_sendtargets_state {
         int dispatched;
         int completed;
+        int failed;
+        int succeeded;
+        bool expect_failure;
 };
 
 static int
@@ -55,14 +59,35 @@ test_iscsi_sendtargets_txrx(struct test_iscsi_sendtargets_state *state)
 }
 
 static void
-test_iscsi_sendtargets_simple_cb(struct iscsi_context *iscsi _U_, int status,
+test_iscsi_sendtargets_cb(struct iscsi_context *iscsi _U_, int status,
-                                 void *command_data, void *private_data)
+                          void *command_data _U_, void *private_data)
 {
         struct test_iscsi_sendtargets_state *state = private_data;
-        struct iscsi_discovery_address *da;
 
         state->completed++;
-        CU_ASSERT_EQUAL(status, 0);
+        if (state->expect_failure) {
+                CU_ASSERT_NOT_EQUAL(status, 0);
+        } else {
+                CU_ASSERT_EQUAL(status, 0);
+        }
+
+        if (status != 0) {
+                logging(LOG_VERBOSE, "non-zero Text response %d",
+                        state->completed);
+                state->failed++;
+                return;
+        }
+        state->succeeded++;
+        logging(LOG_VERBOSE, "zero Text response %d", state->completed);
+}
+
+static void
+test_iscsi_sendtargets_simple_cb(struct iscsi_context *iscsi, int status,
+                                 void *command_data, void *private_data)
+{
+        struct iscsi_discovery_address *da;
+
+        test_iscsi_sendtargets_cb(iscsi, status, command_data, private_data);
         for (da = command_data; da != NULL; da = da->next) {
                 struct iscsi_target_portal *po;
                 logging(LOG_VERBOSE, "Target: %s", da->target_name);
@@ -95,6 +120,116 @@ test_iscsi_sendtargets_simple(void)
         CU_ASSERT_EQUAL(ret, 0);
         state.dispatched++;
 
+        state.expect_failure = false;
         ret = test_iscsi_sendtargets_txrx(&state);
         CU_ASSERT_EQUAL(ret, 0);
+        CU_ASSERT_EQUAL(state.failed, 0);
+        CU_ASSERT_EQUAL(state.succeeded, 1);
+}
+
+int
+test_iscsi_text_req_queue(struct iscsi_context *iscsi,
+                          const char *kv_data,
+                          iscsi_command_cb cb,
+                          struct test_iscsi_sendtargets_state *state)
+{
+        struct iscsi_pdu *pdu;
+        int ret;
+
+        pdu = iscsi_allocate_pdu(iscsi, ISCSI_PDU_TEXT_REQUEST,
+                                 ISCSI_PDU_TEXT_RESPONSE,
+                                 iscsi_itt_post_increment(iscsi),
+                                 ISCSI_PDU_DROP_ON_RECONNECT);
+        CU_ASSERT_PTR_NOT_NULL_FATAL(pdu);
+
+        iscsi_pdu_set_immediate(pdu);
+        iscsi_pdu_set_cmdsn(pdu, iscsi->cmdsn);
+        iscsi_pdu_set_pduflags(pdu, ISCSI_PDU_TEXT_FINAL);
+        iscsi_pdu_set_ttt(pdu, 0xffffffff);
+
+        ret = iscsi_pdu_add_data(iscsi, pdu, (unsigned char *)kv_data,
+                                 strlen(kv_data) + 1);
+        CU_ASSERT_EQUAL_FATAL(ret, 0);
+
+        pdu->callback = cb;
+        pdu->private_data = state;
+
+        ret = iscsi_queue_pdu(iscsi, pdu);
+        CU_ASSERT_EQUAL_FATAL(ret, 0);
+        state->dispatched++;
+        logging(LOG_VERBOSE, "queued Text request %d with %s",
+                state->dispatched, kv_data);
+
+        return 0;
+}
+
+void
+test_iscsi_sendtargets_invalid(void)
+{
+        struct test_iscsi_sendtargets_state state;
+        int ret;
+
+        logging(LOG_VERBOSE, LOG_BLANK_LINE);
+        logging(LOG_VERBOSE, "Test invalid SendTargets Text requests");
+
+        if (sd->iscsi_ctx == NULL) {
+                const char *err = "[SKIPPED] This test is "
+                        "only supported for iSCSI backends";
+                logging(LOG_NORMAL, "%s", err);
+                CU_PASS(err);
+                return;
+        }
+
+        memset(&state, 0, sizeof(state));
+        ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
+                                        "SendTargetsPlease=All", /* bad key */
+                                        test_iscsi_sendtargets_cb,
+                                        &state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        state.expect_failure = true;
+        ret = test_iscsi_sendtargets_txrx(&state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
+                                        "SendTargets=Alle", /* bad val */
+                                        test_iscsi_sendtargets_cb,
+                                        &state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        state.expect_failure = true;
+        ret = test_iscsi_sendtargets_txrx(&state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
+                                        "SendTargets=A", /* bad val */
+                                        test_iscsi_sendtargets_cb,
+                                        &state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        state.expect_failure = true;
+        ret = test_iscsi_sendtargets_txrx(&state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
+                                        "sENDtARGETS=aLL", /* bad case */
+                                        test_iscsi_sendtargets_cb,
+                                        &state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        state.expect_failure = true;
+        ret = test_iscsi_sendtargets_txrx(&state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
+                                        "SendTargets=All", /* valid */
+                                        test_iscsi_sendtargets_cb,
+                                        &state);
+        CU_ASSERT_EQUAL(ret, 0);
+
+        state.expect_failure = false;
+        ret = test_iscsi_sendtargets_txrx(&state);
+        CU_ASSERT_EQUAL(ret, 0);
+        CU_ASSERT_EQUAL(state.failed, 4);
+        CU_ASSERT_EQUAL(state.succeeded, 1);
 }