test_error_recovery.cpp File Reference

Scenario 5: Error Recovery Tests. More...

#include "test_fixtures.h"
#include <catch2/catch_test_macros.hpp>
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/storage_scp.h"
#include "kcenon/pacs/services/storage_scu.h"
#include "kcenon/pacs/services/verification_scp.h"
#include "kcenon/pacs/storage/file_storage.h"
#include "kcenon/pacs/storage/index_database.h"
#include <atomic>
#include <thread>

Include dependency graph for test_error_recovery.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("Invalid SOP Class rejection", "[error][sop_class]")
	TEST_CASE ("Server rejection of all stores", "[error][rejection]")
	TEST_CASE ("Connection to offline server and retry", "[error][retry]")
	TEST_CASE ("Server restart during operations", "[error][restart]")
	TEST_CASE ("Timeout during slow processing", "[error][timeout]")
	TEST_CASE ("Association abort handling", "[error][abort]")
	TEST_CASE ("Multiple rapid aborts", "[error][rapid_abort]")
	TEST_CASE ("Duplicate SOP Instance handling", "[error][duplicate]")

Detailed Description

Scenario 5: Error Recovery Tests.

Tests system error handling and recovery:

1. Send file with invalid SOP Class -> Verify rejection
2. Send file during SCP restart -> Verify retry success
3. Send to wrong AE title -> Verify rejection
4. Test timeout handling
5. Test malformed data handling

See also

Issue #111 - Integration Test Suite

Definition in file test_error_recovery.cpp.

Function Documentation

TEST_CASE() [1/8]

TEST_CASE	(	"Association abort handling"	,
		""	[error][abort] )

Definition at line 499 of file test_error_recovery.cpp.

                                                          {
    auto port = find_available_port();
    error_test_server server(port, "ABORT_SCP");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    association_config config;
    config.calling_ae_title = "ABORT_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.25";
    config.proposed_contexts.push_back({
        1,
        std::string(verification_sop_class_uid),
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
 
    // Abort instead of graceful release
    assoc.abort();
 
    // Server should handle the abort gracefully
    // New connections should still work
    auto new_connect = test_association::connect(
        "localhost", port, server.ae_title(), "AFTER_ABORT",
        {std::string(verification_sop_class_uid)});
    REQUIRE(new_connect.is_ok());
    (void)new_connect.value().release(default_timeout());
 
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [2/8]

TEST_CASE	(	"Connection to offline server and retry"	,
		""	[error][retry] )

Definition at line 354 of file test_error_recovery.cpp.

                                                                      {
    auto port = find_available_port();
 
    // First, try to connect when server is not running
    auto connect_result = test_association::connect(
        "localhost",
        port,
        "OFFLINE_SCP",
        "RETRY_SCU",
        {std::string(verification_sop_class_uid)}
    );
 
    REQUIRE(connect_result.is_err());
 
    // Now start the server
    error_test_server server(port, "OFFLINE_SCP");
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Retry connection - should succeed now
    auto retry_result = test_association::connect(
        "localhost",
        port,
        server.ae_title(),
        "RETRY_SCU",
        {std::string(verification_sop_class_uid)}
    );
 
    REQUIRE(retry_result.is_ok());
    (void)retry_result.value().release(default_timeout());
 
    server.stop();
}

References kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [3/8]

TEST_CASE	(	"Duplicate SOP Instance handling"	,
		""	[error][duplicate] )

Definition at line 586 of file test_error_recovery.cpp.

                                                                   {
    auto port = find_available_port();
    error_test_server server(port, "DUP_SCP");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    association_config config;
    config.calling_ae_title = "DUP_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.27";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
    storage_scu scu;
 
    // Create dataset with fixed SOP Instance UID
    auto sop_instance_uid = generate_uid();
    auto dataset = generate_ct_dataset();
    dataset.set_string(tags::sop_instance_uid, vr_type::UI, sop_instance_uid);
 
    // First store should succeed
    auto result1 = scu.store(assoc, dataset);
    REQUIRE(result1.is_ok());
    REQUIRE(result1.value().is_success());
 
    // Second store with same SOP Instance UID
    // Behavior depends on server implementation:
    // - Could overwrite (success)
    // - Could reject as duplicate (error)
    // - Could return warning
    auto result2 = scu.store(assoc, dataset);
    REQUIRE(result2.is_ok());
    // Either success (overwrite) or warning (duplicate) is acceptable
 
    (void)assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::storage_scu::store().

Here is the call graph for this function:

TEST_CASE() [4/8]

TEST_CASE	(	"Invalid SOP Class rejection"	,
		""	[error][sop_class] )

Definition at line 265 of file test_error_recovery.cpp.

                                                               {
    auto port = find_available_port();
    error_test_server server(port, "ERROR_SCP");
    server.add_accepted_sop_class("1.2.840.10008.5.1.4.1.1.2");  // Only CT
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Try to store MR image (not in accepted list)
    association_config config;
    config.calling_ae_title = "ERROR_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.21";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.4",  // MR Image Storage
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
 
    // MR context should be rejected at association level or store level
    auto mr_context = assoc.accepted_context_id("1.2.840.10008.5.1.4.1.1.4");
 
    if (mr_context) {
        // If context was accepted, store should fail
        storage_scu scu;
        auto mr_dataset = generate_mr_dataset();
        auto result = scu.store(assoc, mr_dataset);
 
        if (result.is_ok()) {
            // Server should reject with SOP class not supported
            REQUIRE_FALSE(result.value().is_success());
        }
    }
    // If context was not accepted, that's also valid behavior
 
    (void)assoc.release(default_timeout());
 
    // Verify server rejected the request
    REQUIRE(server.stored_count() == 0);
 
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_mr_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::storage_scu::store().

Here is the call graph for this function:

TEST_CASE() [5/8]

TEST_CASE	(	"Multiple rapid aborts"	,
		""	[error][rapid_abort] )

Definition at line 536 of file test_error_recovery.cpp.

                                                           {
    auto port = find_available_port();
    error_test_server server(port, "RAPID_ABORT_SCP");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    constexpr int num_aborts = 10;
 
    for (int i = 0; i < num_aborts; ++i) {
        association_config config;
        config.calling_ae_title = "ABORT_" + std::to_string(i);
        config.called_ae_title = server.ae_title();
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.26";
        config.proposed_contexts.push_back({
            1,
            std::string(verification_sop_class_uid),
            {"1.2.840.10008.1.2.1"}
        });
 
        auto connect = association::connect(
            "localhost", port, config, default_timeout());
 
        if (connect.is_ok()) {
            connect.value().abort();
        }
    }
 
    // Server should still be operational
    auto final_connect = test_association::connect(
        "localhost", port, server.ae_title(), "FINAL_CHECK",
        {std::string(verification_sop_class_uid)});
    REQUIRE(final_connect.is_ok());
 
    // Send an echo to verify server is responsive
    auto& assoc = final_connect.value();
    auto ctx = assoc.accepted_context_id(verification_sop_class_uid);
    REQUIRE(ctx.has_value());
 
    auto echo_rq = make_c_echo_rq(1, verification_sop_class_uid);
    REQUIRE(assoc.send_dimse(*ctx, echo_rq).is_ok());
 
    auto recv = assoc.receive_dimse(default_timeout());
    REQUIRE(recv.is_ok());
    REQUIRE(recv.value().second.status() == status_success);
 
    (void)assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_echo_rq(), kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [6/8]

TEST_CASE	(	"Server rejection of all stores"	,
		""	[error][rejection] )

Definition at line 314 of file test_error_recovery.cpp.

                                                                  {
    auto port = find_available_port();
    error_test_server server(port, "ERROR_SCP");
    server.set_reject_all(true);
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    association_config config;
    config.calling_ae_title = "ERROR_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.22";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
    storage_scu scu;
 
    auto dataset = generate_ct_dataset();
    auto result = scu.store(assoc, dataset);
 
    REQUIRE(result.is_ok());
    REQUIRE_FALSE(result.value().is_success());
    REQUIRE(result.value().status == static_cast<uint16_t>(storage_status::out_of_resources));
 
    (void)assoc.release(default_timeout());
 
    REQUIRE(server.stored_count() == 0);
    REQUIRE(server.rejected_count() == 1);
 
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::storage_scu::store().

Here is the call graph for this function:

TEST_CASE() [7/8]

TEST_CASE	(	"Server restart during operations"	,
		""	[error][restart] )

Definition at line 388 of file test_error_recovery.cpp.

                                                                  {
    auto port = find_available_port();
    error_test_server server(port, "RESTART_SCP");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Store some files first
    {
        association_config config;
        config.calling_ae_title = "PRE_RESTART";
        config.called_ae_title = server.ae_title();
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.23";
        config.proposed_contexts.push_back({
            1,
            "1.2.840.10008.5.1.4.1.1.2",
            {"1.2.840.10008.1.2.1"}
        });
 
        auto connect = association::connect("localhost", port, config, default_timeout());
        REQUIRE(connect.is_ok());
 
        storage_scu scu;
        auto ds = generate_ct_dataset();
        auto result = scu.store(connect.value(), ds);
        REQUIRE(result.is_ok());
        REQUIRE(result.value().is_success());
 
        (void)connect.value().release(default_timeout());
    }
 
    REQUIRE(server.stored_count() == 1);
 
    // Stop the server
    server.stop();
 
    // Try to connect - should fail
    auto offline_connect = test_association::connect(
        "localhost", port, "RESTART_SCP", "POST_STOP",
        {"1.2.840.10008.5.1.4.1.1.2"});
    REQUIRE(offline_connect.is_err());
 
    // Note: For a true restart test, we'd need to create a new server
    // since the database/storage is tied to the test_directory lifetime
    // Here we demonstrate the connection failure when server is stopped
 
    // Create new server on same port
    error_test_server new_server(port, "RESTART_SCP");
    REQUIRE(new_server.initialize());
    REQUIRE(new_server.start());
 
    // Retry connection - should succeed
    auto retry_connect = test_association::connect(
        "localhost", port, new_server.ae_title(), "POST_RESTART",
        {"1.2.840.10008.5.1.4.1.1.2"});
    REQUIRE(retry_connect.is_ok());
    (void)retry_connect.value().release(default_timeout());
 
    new_server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::storage_scu::store().

Here is the call graph for this function:

TEST_CASE() [8/8]

TEST_CASE	(	"Timeout during slow processing"	,
		""	[error][timeout] )

Definition at line 449 of file test_error_recovery.cpp.

                                                                {
    auto port = find_available_port();
    error_test_server server(port, "SLOW_SCP");
    server.set_simulate_delay(std::chrono::milliseconds{2000});  // 2 second delay
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    association_config config;
    config.calling_ae_title = "TIMEOUT_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.24";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
 
    // Use very short timeout
    storage_scu_config scu_config;
    scu_config.response_timeout = std::chrono::milliseconds{500};  // Very short
    storage_scu scu{scu_config};
 
    auto dataset = generate_ct_dataset();
 
    // This may timeout or succeed depending on timing
    auto result = scu.store(assoc, dataset);
 
    // Either timeout error or slow success is acceptable
    // The key is that the system handles it gracefully without crashing
    if (result.is_err()) {
        // Timeout is expected behavior
        INFO("Store timed out as expected");
    } else {
        // If it succeeded, verify the result
        INFO("Store completed despite slow processing");
    }
 
    // Abort the association since we might have a timeout situation
    assoc.abort();
 
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::services::storage_scu_config::response_timeout.

Here is the call graph for this function: