test_worklist_mpps.cpp File Reference

Scenario 3: Worklist to MPPS Workflow Tests. More...

#include "test_fixtures.h"
#include <catch2/catch_test_macros.hpp>
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/mpps_scp.h"
#include "kcenon/pacs/services/verification_scp.h"
#include "kcenon/pacs/services/worklist_scp.h"
#include <mutex>
#include <vector>

Include dependency graph for test_worklist_mpps.cpp:

Go to the source code of this file.

Namespaces
namespace	local_tags

Functions
	TEST_CASE ("Worklist query returns scheduled procedures", "[worklist][query]")
	TEST_CASE ("Complete MPPS workflow", "[worklist][mpps][workflow]")
	TEST_CASE ("MPPS discontinue workflow", "[worklist][mpps][discontinue]")
	TEST_CASE ("MPPS cannot modify completed procedure", "[worklist][mpps][error]")

Detailed Description

Scenario 3: Worklist to MPPS Workflow Tests.

Tests the complete worklist and MPPS workflow:

1. Start RIS Mock (Worklist + MPPS SCP)
2. Insert scheduled procedure
3. Query Worklist -> Verify scheduled item
4. Create MPPS (IN PROGRESS)
5. Update MPPS (COMPLETED)
6. Verify MPPS recorded
7. Stop RIS Mock

See also

Issue #111 - Integration Test Suite

Definition in file test_worklist_mpps.cpp.

Function Documentation

TEST_CASE() [1/4]

TEST_CASE	(	"Complete MPPS workflow"	,
		""	[worklist][mpps][workflow] )

Definition at line 423 of file test_worklist_mpps.cpp.

                                                                  {
    auto port = find_available_port();
    ris_mock_server ris(port, "RIS_MOCK");
 
    REQUIRE(ris.initialize());
    REQUIRE(ris.start());
 
    // Add a scheduled procedure
    auto procedure = create_scheduled_procedure(
        "MPPS^TEST", "MPPS001", "CT", "CT_SCANNER", "CT Head", "20240201", "090000");
    ris.add_scheduled_procedure(procedure);
 
    auto study_uid = procedure.get_string(tags::study_instance_uid);
    auto mpps_uid = generate_uid();
 
    // Step 1: Query worklist to get scheduled procedure
    association_config wl_config;
    wl_config.calling_ae_title = "CT_SCANNER";
    wl_config.called_ae_title = ris.ae_title();
    wl_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
    wl_config.proposed_contexts.push_back({
        1,
        std::string(worklist_find_sop_class_uid),
        {"1.2.840.10008.1.2.1"}
    });
 
    auto wl_connect = association::connect("localhost", port, wl_config, default_timeout());
    REQUIRE(wl_connect.is_ok());
 
    auto& wl_assoc = wl_connect.value();
 
    dicom_dataset wl_query;
    wl_query.set_string(tags::patient_id, vr_type::LO, "MPPS001");
    wl_query.set_string(tags::modality, vr_type::CS, "CT");
 
    auto wl_ctx = *wl_assoc.accepted_context_id(worklist_find_sop_class_uid);
    auto wl_rq = make_c_find_rq(1, worklist_find_sop_class_uid);
    wl_rq.set_dataset(std::move(wl_query));
    (void)wl_assoc.send_dimse(wl_ctx, wl_rq);
 
    std::vector<dicom_dataset> wl_results;
    while (true) {
        auto recv = wl_assoc.receive_dimse(default_timeout());
        if (recv.is_err()) break;
        auto& [ctx, rsp] = recv.value();
        if (rsp.status() == status_success) break;
        if (rsp.status() == status_pending && rsp.has_dataset()) {
            auto ds_result = rsp.dataset();
            if (ds_result.is_ok()) {
                wl_results.push_back(ds_result.value().get());
            }
        }
    }
 
    REQUIRE(wl_results.size() == 1);
    (void)wl_assoc.release(default_timeout());
 
    // Step 2: Create MPPS (IN PROGRESS)
    association_config mpps_config;
    mpps_config.calling_ae_title = "CT_SCANNER";
    mpps_config.called_ae_title = ris.ae_title();
    mpps_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
    mpps_config.proposed_contexts.push_back({
        1,
        std::string(mpps_sop_class_uid),
        {"1.2.840.10008.1.2.1"}
    });
 
    auto mpps_connect = association::connect("localhost", port, mpps_config, default_timeout());
    REQUIRE(mpps_connect.is_ok());
 
    auto& mpps_assoc = mpps_connect.value();
 
    // Create N-CREATE for MPPS IN PROGRESS
    dicom_dataset mpps_create_ds;
    mpps_create_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "IN PROGRESS");
    mpps_create_ds.set_string(tags::performed_procedure_step_start_date, vr_type::DA, "20240201");
    mpps_create_ds.set_string(tags::performed_procedure_step_start_time, vr_type::TM, "091500");
    mpps_create_ds.set_string(performed_station_ae_title, vr_type::AE, "CT_SCANNER");
    mpps_create_ds.set_string(tags::modality, vr_type::CS, "CT");
    mpps_create_ds.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
    mpps_create_ds.set_string(tags::patient_name, vr_type::PN, "MPPS^TEST");
    mpps_create_ds.set_string(tags::patient_id, vr_type::LO, "MPPS001");
 
    auto mpps_ctx = *mpps_assoc.accepted_context_id(mpps_sop_class_uid);
    auto n_create_rq = make_n_create_rq(1, mpps_sop_class_uid, mpps_uid);
    n_create_rq.set_dataset(std::move(mpps_create_ds));
    (void)mpps_assoc.send_dimse(mpps_ctx, n_create_rq);
 
    auto create_recv = mpps_assoc.receive_dimse(default_timeout());
    REQUIRE(create_recv.is_ok());
    auto& [create_ctx, create_rsp] = create_recv.value();
    REQUIRE(create_rsp.command() == command_field::n_create_rsp);
    REQUIRE(create_rsp.status() == status_success);
 
    // Verify MPPS was created
    REQUIRE(ris.mpps_count() == 1);
    auto mpps_opt = ris.get_mpps(mpps_uid);
    REQUIRE(mpps_opt.has_value());
    REQUIRE(mpps_opt->status == mpps_status::in_progress);
 
    // Step 3: Update MPPS (COMPLETED)
    dicom_dataset mpps_set_ds;
    mpps_set_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "COMPLETED");
    mpps_set_ds.set_string(performed_procedure_step_end_date, vr_type::DA, "20240201");
    mpps_set_ds.set_string(performed_procedure_step_end_time, vr_type::TM, "093000");
 
    auto n_set_rq = make_n_set_rq(2, mpps_sop_class_uid, mpps_uid);
    n_set_rq.set_dataset(std::move(mpps_set_ds));
    (void)mpps_assoc.send_dimse(mpps_ctx, n_set_rq);
 
    auto set_recv = mpps_assoc.receive_dimse(default_timeout());
    REQUIRE(set_recv.is_ok());
    auto& [set_ctx, set_rsp] = set_recv.value();
    REQUIRE(set_rsp.command() == command_field::n_set_rsp);
    REQUIRE(set_rsp.status() == status_success);
 
    // Verify MPPS was updated
    mpps_opt = ris.get_mpps(mpps_uid);
    REQUIRE(mpps_opt.has_value());
    REQUIRE(mpps_opt->status == mpps_status::completed);
 
    (void)mpps_assoc.release(default_timeout());
    ris.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_uid(), kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_find_rq(), kcenon::pacs::network::dimse::make_n_create_rq(), kcenon::pacs::network::dimse::make_n_set_rq(), kcenon::pacs::services::mpps_sop_class_uid, kcenon::pacs::network::dimse::n_create_rq, kcenon::pacs::network::dimse::n_set_rq, kcenon::pacs::services::mpps_tags::performed_procedure_step_end_date, kcenon::pacs::services::mpps_tags::performed_procedure_step_end_time, kcenon::pacs::services::mpps_tags::performed_station_ae_title, kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::worklist_find_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [2/4]

TEST_CASE	(	"MPPS cannot modify completed procedure"	,
		""	[worklist][mpps][error] )

Definition at line 617 of file test_worklist_mpps.cpp.

                                                                               {
    auto port = find_available_port();
    ris_mock_server ris(port, "RIS_MOCK");
 
    REQUIRE(ris.initialize());
    REQUIRE(ris.start());
 
    auto mpps_uid = generate_uid();
 
    association_config config;
    config.calling_ae_title = "CT_SCANNER";
    config.called_ae_title = ris.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
    config.proposed_contexts.push_back({
        1,
        std::string(mpps_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();
    auto ctx = *assoc.accepted_context_id(mpps_sop_class_uid);
 
    // Create and complete MPPS
    dicom_dataset create_ds;
    create_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "IN PROGRESS");
    create_ds.set_string(tags::performed_procedure_step_start_date, vr_type::DA, "20240201");
    create_ds.set_string(tags::performed_procedure_step_start_time, vr_type::TM, "110000");
    create_ds.set_string(performed_station_ae_title, vr_type::AE, "CT_SCANNER");
    create_ds.set_string(tags::modality, vr_type::CS, "CT");
 
    auto n_create = make_n_create_rq(1, mpps_sop_class_uid, mpps_uid);
    n_create.set_dataset(std::move(create_ds));
    (void)assoc.send_dimse(ctx, n_create);
    auto create_recv = assoc.receive_dimse(default_timeout());
    REQUIRE(create_recv.is_ok());
 
    // Complete the MPPS
    dicom_dataset complete_ds;
    complete_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "COMPLETED");
    auto n_set_complete = make_n_set_rq(2, mpps_sop_class_uid, mpps_uid);
    n_set_complete.set_dataset(std::move(complete_ds));
    (void)assoc.send_dimse(ctx, n_set_complete);
    auto complete_recv = assoc.receive_dimse(default_timeout());
    REQUIRE(complete_recv.is_ok());
 
    // Try to modify completed MPPS - should fail
    dicom_dataset modify_ds;
    modify_ds.set_string(performed_procedure_step_description, vr_type::LO, "Changed");
    auto n_set_modify = make_n_set_rq(3, mpps_sop_class_uid, mpps_uid);
    n_set_modify.set_dataset(std::move(modify_ds));
    (void)assoc.send_dimse(ctx, n_set_modify);
 
    auto modify_recv = assoc.receive_dimse(default_timeout());
    REQUIRE(modify_recv.is_ok());
    // Should return error status
    REQUIRE(modify_recv.value().second.status() != status_success);
 
    (void)assoc.release(default_timeout());
    ris.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_uid(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_n_create_rq(), kcenon::pacs::network::dimse::make_n_set_rq(), kcenon::pacs::services::mpps_sop_class_uid, kcenon::pacs::services::mpps_tags::performed_procedure_step_description, kcenon::pacs::services::mpps_tags::performed_station_ae_title, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::core::dicom_dataset::set_string().

Here is the call graph for this function:

TEST_CASE() [3/4]

TEST_CASE	(	"MPPS discontinue workflow"	,
		""	[worklist][mpps][discontinue] )

Definition at line 549 of file test_worklist_mpps.cpp.

                                                                        {
    auto port = find_available_port();
    ris_mock_server ris(port, "RIS_MOCK");
 
    REQUIRE(ris.initialize());
    REQUIRE(ris.start());
 
    auto mpps_uid = generate_uid();
 
    association_config config;
    config.calling_ae_title = "CT_SCANNER";
    config.called_ae_title = ris.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
    config.proposed_contexts.push_back({
        1,
        std::string(mpps_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();
 
    // Create MPPS IN PROGRESS
    dicom_dataset mpps_ds;
    mpps_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "IN PROGRESS");
    mpps_ds.set_string(tags::performed_procedure_step_start_date, vr_type::DA, "20240201");
    mpps_ds.set_string(tags::performed_procedure_step_start_time, vr_type::TM, "100000");
    mpps_ds.set_string(performed_station_ae_title, vr_type::AE, "CT_SCANNER");
    mpps_ds.set_string(tags::modality, vr_type::CS, "CT");
    mpps_ds.set_string(tags::study_instance_uid, vr_type::UI, generate_uid());
    mpps_ds.set_string(tags::patient_name, vr_type::PN, "DISCONTINUE^TEST");
    mpps_ds.set_string(tags::patient_id, vr_type::LO, "DISC001");
 
    auto ctx = *assoc.accepted_context_id(mpps_sop_class_uid);
    auto n_create = make_n_create_rq(1, mpps_sop_class_uid, mpps_uid);
    n_create.set_dataset(std::move(mpps_ds));
    (void)assoc.send_dimse(ctx, n_create);
 
    auto create_recv = assoc.receive_dimse(default_timeout());
    REQUIRE(create_recv.is_ok());
    REQUIRE(create_recv.value().second.status() == status_success);
 
    // Discontinue the procedure
    dicom_dataset disc_ds;
    disc_ds.set_string(tags::performed_procedure_step_status, vr_type::CS, "DISCONTINUED");
    disc_ds.set_string(performed_procedure_step_end_date, vr_type::DA, "20240201");
    disc_ds.set_string(performed_procedure_step_end_time, vr_type::TM, "101500");
    disc_ds.set_string(performed_procedure_step_discontinuation_reason_code_sequence, vr_type::SQ, "");
 
    auto n_set = make_n_set_rq(2, mpps_sop_class_uid, mpps_uid);
    n_set.set_dataset(std::move(disc_ds));
    (void)assoc.send_dimse(ctx, n_set);
 
    auto set_recv = assoc.receive_dimse(default_timeout());
    REQUIRE(set_recv.is_ok());
    REQUIRE(set_recv.value().second.status() == status_success);
 
    // Verify discontinued
    auto mpps_opt = ris.get_mpps(mpps_uid);
    REQUIRE(mpps_opt.has_value());
    REQUIRE(mpps_opt->status == mpps_status::discontinued);
 
    (void)assoc.release(default_timeout());
    ris.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_uid(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_n_create_rq(), kcenon::pacs::network::dimse::make_n_set_rq(), kcenon::pacs::services::mpps_sop_class_uid, kcenon::pacs::services::mpps_tags::performed_procedure_step_end_date, kcenon::pacs::services::mpps_tags::performed_procedure_step_end_time, kcenon::pacs::services::mpps_tags::performed_station_ae_title, kcenon::pacs::network::association_config::proposed_contexts, and kcenon::pacs::core::dicom_dataset::set_string().

Here is the call graph for this function:

TEST_CASE() [4/4]

TEST_CASE	(	"Worklist query returns scheduled procedures"	,
		""	[worklist][query] )

Definition at line 303 of file test_worklist_mpps.cpp.

                                                                              {
    auto port = find_available_port();
    ris_mock_server ris(port, "RIS_MOCK");
 
    REQUIRE(ris.initialize());
    REQUIRE(ris.start());
 
    // Add scheduled procedures
    ris.add_scheduled_procedure(create_scheduled_procedure(
        "TEST^PATIENT1", "P001", "CT", "CT_SCANNER", "CT Chest", "20240201", "090000"));
    ris.add_scheduled_procedure(create_scheduled_procedure(
        "TEST^PATIENT2", "P002", "MR", "MR_SCANNER", "MR Brain", "20240201", "100000"));
    ris.add_scheduled_procedure(create_scheduled_procedure(
        "TEST^PATIENT3", "P003", "CT", "CT_SCANNER", "CT Abdomen", "20240202", "080000"));
 
    SECTION("Query all scheduled procedures") {
        association_config config;
        config.calling_ae_title = "MODALITY";
        config.called_ae_title = ris.ae_title();
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
        config.proposed_contexts.push_back({
            1,
            std::string(worklist_find_sop_class_uid),
            {"1.2.840.10008.1.2.1", "1.2.840.10008.1.2"}
        });
 
        auto connect_result = association::connect(
            "localhost", port, config, default_timeout());
        REQUIRE(connect_result.is_ok());
 
        auto& assoc = connect_result.value();
 
        // Query all (empty criteria = return all)
        dicom_dataset query_keys;
        query_keys.set_string(tags::patient_name, vr_type::PN, "");
        query_keys.set_string(tags::patient_id, vr_type::LO, "");
        query_keys.set_string(tags::modality, vr_type::CS, "");
        query_keys.set_string(tags::scheduled_procedure_step_start_date, vr_type::DA, "");
        query_keys.set_string(tags::scheduled_station_ae_title, vr_type::AE, "");
 
        auto context_id = *assoc.accepted_context_id(worklist_find_sop_class_uid);
        auto find_rq = make_c_find_rq(1, worklist_find_sop_class_uid);
        find_rq.set_dataset(std::move(query_keys));
        (void)assoc.send_dimse(context_id, find_rq);
 
        std::vector<dicom_dataset> results;
        while (true) {
            auto recv_result = assoc.receive_dimse(default_timeout());
            if (recv_result.is_err()) break;
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) break;
            if (rsp.status() == status_pending && rsp.has_dataset()) {
                auto ds_result = rsp.dataset();
                if (ds_result.is_ok()) {
                    results.push_back(ds_result.value().get());
                }
            }
        }
 
        REQUIRE(results.size() == 3);
 
        (void)assoc.release(default_timeout());
    }
 
    SECTION("Query by modality filter") {
        association_config config;
        config.calling_ae_title = "CT_SCANNER";
        config.called_ae_title = ris.ae_title();
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.6";
        config.proposed_contexts.push_back({
            1,
            std::string(worklist_find_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();
 
        // Query CT only
        dicom_dataset query_keys;
        query_keys.set_string(tags::patient_name, vr_type::PN, "");
        query_keys.set_string(tags::modality, vr_type::CS, "CT");
        query_keys.set_string(tags::scheduled_station_ae_title, vr_type::AE, "");
 
        auto context_id = *assoc.accepted_context_id(worklist_find_sop_class_uid);
        auto find_rq = make_c_find_rq(1, worklist_find_sop_class_uid);
        find_rq.set_dataset(std::move(query_keys));
        (void)assoc.send_dimse(context_id, find_rq);
 
        std::vector<dicom_dataset> results;
        while (true) {
            auto recv_result = assoc.receive_dimse(default_timeout());
            if (recv_result.is_err()) break;
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) break;
            if (rsp.status() == status_pending && rsp.has_dataset()) {
                auto ds_result = rsp.dataset();
                if (ds_result.is_ok()) {
                    results.push_back(ds_result.value().get());
                }
            }
        }
 
        // Should return 2 CT procedures
        REQUIRE(results.size() == 2);
        for (const auto& result : results) {
            REQUIRE(result.get_string(tags::modality) == "CT");
        }
 
        (void)assoc.release(default_timeout());
    }
 
    ris.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::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_find_rq(), kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::worklist_find_sop_class_uid.

Here is the call graph for this function: