test_connectivity.cpp File Reference

Scenario 1: Basic Connectivity Tests. More...

#include "test_fixtures.h"
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/verification_scp.h"
#include <thread>

Include dependency graph for test_connectivity.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("C-ECHO basic connectivity", "[connectivity][echo]")
	TEST_CASE ("Multiple sequential C-ECHO requests", "[connectivity][echo]")
	TEST_CASE ("Multiple concurrent associations", "[connectivity][echo]")
	TEST_CASE ("Connection to non-existent server fails gracefully", "[connectivity][error]")
	TEST_CASE ("Wrong AE title handling", "[connectivity][ae_title]")
	TEST_CASE ("Association timeout handling", "[connectivity][timeout]")

Detailed Description

Scenario 1: Basic Connectivity Tests.

Tests basic DICOM connectivity using C-ECHO service. Validates that Echo SCP and SCU can communicate successfully.

See also

Issue #111 - Integration Test Suite

Test Workflow:

1. Start Echo SCP
2. Run Echo SCU -> Verify success
3. Stop Echo SCP

Definition in file test_connectivity.cpp.

Function Documentation

TEST_CASE() [1/6]

TEST_CASE	(	"Association timeout handling"	,
		""	[connectivity][timeout] )

Definition at line 223 of file test_connectivity.cpp.

                                                                     {
    auto port = find_available_port();
    test_server server(port, "ECHO_SCP");
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    auto connect_result = test_association::connect(
        "localhost", port, server.ae_title(), "ECHO_SCU",
        {std::string(verification_sop_class_uid)}
    );
    REQUIRE(connect_result.is_ok());
    auto& assoc = connect_result.value();
 
    // Try to receive without sending - should timeout
    auto short_timeout = std::chrono::milliseconds{100};
    auto recv_result = assoc.receive_dimse(short_timeout);
 
    // Should timeout (error result)
    REQUIRE(recv_result.is_err());
 
    // Abort connection (since we didn't properly communicate)
    assoc.abort();
 
    server.stop();
}

References kcenon::pacs::integration_test::test_server::ae_title(), kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::test_server::register_service(), kcenon::pacs::integration_test::test_server::start(), and kcenon::pacs::integration_test::test_server::stop().

Here is the call graph for this function:

TEST_CASE() [2/6]

TEST_CASE	(	"C-ECHO basic connectivity"	,
		""	[connectivity][echo] )

Definition at line 35 of file test_connectivity.cpp.

                                                               {
    SECTION("Echo SCP accepts connection and responds to C-ECHO") {
        // Step 1: Start Echo SCP
        auto port = find_available_port();
        test_server server(port, "ECHO_SCP");
        server.register_service(std::make_shared<verification_scp>());
 
        REQUIRE(server.start());
        REQUIRE(server.is_running());
 
        // Step 2: Connect and send C-ECHO
        auto connect_result = test_association::connect(
            "localhost",
            port,
            server.ae_title(),
            "ECHO_SCU",
            {std::string(verification_sop_class_uid)}
        );
 
        REQUIRE(connect_result.is_ok());
        auto& assoc = connect_result.value();
 
        // Verify we have accepted context for verification
        REQUIRE(assoc.has_accepted_context(verification_sop_class_uid));
 
        auto context_id_opt = assoc.accepted_context_id(verification_sop_class_uid);
        REQUIRE(context_id_opt.has_value());
        uint8_t context_id = *context_id_opt;
 
        // Create and send C-ECHO request
        auto echo_rq = make_c_echo_rq(1, verification_sop_class_uid);
        auto send_result = assoc.send_dimse(context_id, echo_rq);
        REQUIRE(send_result.is_ok());
 
        // Receive C-ECHO response
        auto recv_result = assoc.receive_dimse(default_timeout());
        REQUIRE(recv_result.is_ok());
 
        auto& [recv_context_id, echo_rsp] = recv_result.value();
        REQUIRE(echo_rsp.command() == command_field::c_echo_rsp);
        REQUIRE(echo_rsp.status() == status_success);
 
        // Release association gracefully
        auto release_result = assoc.release(default_timeout());
        REQUIRE(release_result.is_ok());
 
        // Step 3: Stop server
        server.stop();
        REQUIRE_FALSE(server.is_running());
    }
}

References kcenon::pacs::integration_test::test_server::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::test_server::is_running(), kcenon::pacs::network::dimse::make_c_echo_rq(), kcenon::pacs::integration_test::test_server::register_service(), kcenon::pacs::integration_test::test_server::start(), kcenon::pacs::integration_test::test_server::stop(), and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [3/6]

TEST_CASE	(	"Connection to non-existent server fails gracefully"	,
		""	[connectivity][error] )

Definition at line 181 of file test_connectivity.cpp.

                                                                                         {
    // Try to connect to a port that's not listening
    auto connect_result = test_association::connect(
        "localhost",
        find_available_port() + 1000,  // Very unlikely to be in use
        "NONEXISTENT",
        "ECHO_SCU",
        {std::string(verification_sop_class_uid)}
    );
 
    REQUIRE(connect_result.is_err());
}

References kcenon::pacs::integration_test::test_association::connect(), 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() [4/6]

TEST_CASE	(	"Multiple concurrent associations"	,
		""	[connectivity][echo] )

Definition at line 123 of file test_connectivity.cpp.

                                                                      {
    auto port = find_available_port();
    test_server server(port, "ECHO_SCP");
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    constexpr int num_associations = 5;
    std::vector<std::thread> threads;
    std::atomic<int> success_count{0};
 
    for (int i = 0; i < num_associations; ++i) {
        threads.emplace_back([&server, &success_count, port, i]() {
            auto connect_result = test_association::connect(
                "localhost", port, server.ae_title(),
                "ECHO_SCU_" + std::to_string(i),
                {std::string(verification_sop_class_uid)}
            );
 
            if (connect_result.is_err()) {
                return;
            }
 
            auto& assoc = connect_result.value();
            auto context_id_opt = assoc.accepted_context_id(verification_sop_class_uid);
            if (!context_id_opt) {
                return;
            }
 
            auto echo_rq = make_c_echo_rq(1, verification_sop_class_uid);
            auto send_result = assoc.send_dimse(*context_id_opt, echo_rq);
            if (send_result.is_err()) {
                return;
            }
 
            auto recv_result = assoc.receive_dimse(default_timeout());
            if (recv_result.is_ok()) {
                auto& [ctx, rsp] = recv_result.value();
                if (rsp.command() == command_field::c_echo_rsp &&
                    rsp.status() == status_success) {
                    ++success_count;
                }
            }
 
            (void)assoc.release(default_timeout());
        });
    }
 
    // Wait for all threads
    for (auto& t : threads) {
        t.join();
    }
 
    server.stop();
 
    REQUIRE(success_count == num_associations);
}

References kcenon::pacs::integration_test::test_server::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::dimse::make_c_echo_rq(), kcenon::pacs::integration_test::test_server::register_service(), kcenon::pacs::integration_test::test_server::start(), kcenon::pacs::integration_test::test_server::stop(), and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [5/6]

TEST_CASE	(	"Multiple sequential C-ECHO requests"	,
		""	[connectivity][echo] )

Definition at line 87 of file test_connectivity.cpp.

                                                                         {
    auto port = find_available_port();
    test_server server(port, "ECHO_SCP");
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    // Connect once
    auto connect_result = test_association::connect(
        "localhost", port, server.ae_title(), "ECHO_SCU",
        {std::string(verification_sop_class_uid)}
    );
    REQUIRE(connect_result.is_ok());
    auto& assoc = connect_result.value();
 
    auto context_id = *assoc.accepted_context_id(verification_sop_class_uid);
 
    // Send multiple C-ECHO requests on same association
    constexpr int echo_count = 5;
    for (int i = 0; i < echo_count; ++i) {
        auto echo_rq = make_c_echo_rq(static_cast<uint16_t>(i + 1), verification_sop_class_uid);
        auto send_result = assoc.send_dimse(context_id, echo_rq);
        REQUIRE(send_result.is_ok());
 
        auto recv_result = assoc.receive_dimse(default_timeout());
        REQUIRE(recv_result.is_ok());
 
        auto& [recv_ctx, echo_rsp] = recv_result.value();
        REQUIRE(echo_rsp.command() == command_field::c_echo_rsp);
        REQUIRE(echo_rsp.status() == status_success);
    }
 
    (void)assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::integration_test::test_server::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::dimse::make_c_echo_rq(), kcenon::pacs::integration_test::test_server::register_service(), kcenon::pacs::integration_test::test_server::start(), kcenon::pacs::integration_test::test_server::stop(), and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [6/6]

TEST_CASE	(	"Wrong AE title handling"	,
		""	[connectivity][ae_title] )

Definition at line 194 of file test_connectivity.cpp.

                                                                 {
    auto port = find_available_port();
    test_server server(port, "CORRECT_AE");
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    // Note: In DICOM, AE title mismatch is typically handled during
    // association negotiation. The server may accept or reject based
    // on configuration. This test validates the connection behavior.
    auto connect_result = test_association::connect(
        "localhost",
        port,
        "WRONG_AE",  // Wrong AE title
        "ECHO_SCU",
        {std::string(verification_sop_class_uid)}
    );
 
    // The result depends on server configuration
    // Some servers reject, some accept any AE title
    // We just verify the operation completes without crash
    if (connect_result.is_ok()) {
        auto& assoc = connect_result.value();
        (void)assoc.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(), kcenon::pacs::integration_test::test_server::register_service(), kcenon::pacs::integration_test::test_server::start(), kcenon::pacs::integration_test::test_server::stop(), and kcenon::pacs::services::verification_sop_class_uid.

Here is the call graph for this function: