test_multimodal_workflow.cpp File Reference

Multi-Modal Clinical Workflow Integration 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/mpps_scp.h"
#include "kcenon/pacs/services/query_scp.h"
#include "kcenon/pacs/services/retrieve_scp.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/services/worklist_scp.h"
#include "kcenon/pacs/storage/file_storage.h"
#include "kcenon/pacs/storage/index_database.h"
#include <atomic>
#include <future>
#include <memory>
#include <mutex>
#include <set>
#include <thread>
#include <vector>

Include dependency graph for test_multimodal_workflow.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("Multi-modal workflow tests", "[workflow][multimodal][integration]")
	TEST_CASE ("Multi-modal workflow with MPPS tracking", "[workflow][mpps][integration]")
	TEST_CASE ("Stress test: High-volume multi-modal storage", "[workflow][.stress][integration]")

Detailed Description

Multi-Modal Clinical Workflow Integration Tests.

Tests comprehensive clinical workflow scenarios that simulate real-world multi-modality patient journeys through the PACS system.

Test Scenarios:

1. Complete Patient Journey: Worklist → CT → MPPS → MR → MPPS → Query
2. Interventional Workflow (XA): Pre-procedure → XA cine → Analysis → Storage
3. Emergency Multi-Modality: Trauma CT → XA intervention → Follow-up CT
4. Concurrent Modality Operations: Multiple scanners storing simultaneously

See also

Issue #138 - Multi-Modal Clinical Workflow Tests

Issue #134 - Integration Test Enhancement Epic

Definition in file test_multimodal_workflow.cpp.

Function Documentation

TEST_CASE() [1/3]

TEST_CASE	(	"Multi-modal workflow tests"	,
		""	[workflow][multimodal][integration] )

Definition at line 573 of file test_multimodal_workflow.cpp.

                                                                               {
    auto port = find_available_port();
    multimodal_pacs_server server(port);
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    SECTION("Scenario 1: Complete patient journey - CT and MR") {
        // This scenario simulates a patient arriving for scheduled CT and MR exams
        // Workflow: Worklist query → CT scan → MPPS → MR scan → MPPS → Query verification
 
        const std::string patient_id = "JOURNEY001";
        const std::string patient_name = "JOURNEY^PATIENT^COMPLETE";
        auto study_uid = generate_uid();
 
        // Step 1: Add scheduled procedures to worklist
        auto ct_worklist = test_data_generator::worklist(patient_id, "CT");
        ct_worklist.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
        server.add_worklist_item(ct_worklist);
 
        auto mr_worklist = test_data_generator::worklist(patient_id, "MR");
        mr_worklist.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
        server.add_worklist_item(mr_worklist);
 
        // Step 2: Perform CT examination
        // Generate CT series (3 images)
        auto ct_series_uid = generate_uid();
        std::vector<dicom_dataset> ct_images;
        for (int i = 0; i < 3; ++i) {
            auto ct = test_data_generator::ct(study_uid);
            ct.set_string(tags::patient_id, vr_type::LO, patient_id);
            ct.set_string(tags::patient_name, vr_type::PN, patient_name);
            ct.set_string(tags::series_instance_uid, vr_type::UI, ct_series_uid);
            ct.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
            ct.set_string(tags::instance_number, vr_type::IS, std::to_string(i + 1));
            ct_images.push_back(std::move(ct));
        }
 
        // Store CT images
        for (const auto& image : ct_images) {
            REQUIRE(store_to_pacs(image, "127.0.0.1", port, server.ae_title(), "CT_SCANNER"));
        }
 
        // Step 3: Perform MR examination
        // Generate MR series (2 images)
        auto mr_series_uid = generate_uid();
        std::vector<dicom_dataset> mr_images;
        for (int i = 0; i < 2; ++i) {
            auto mr = test_data_generator::mr(study_uid);
            mr.set_string(tags::patient_id, vr_type::LO, patient_id);
            mr.set_string(tags::patient_name, vr_type::PN, patient_name);
            mr.set_string(tags::series_instance_uid, vr_type::UI, mr_series_uid);
            mr.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
            mr.set_string(tags::instance_number, vr_type::IS, std::to_string(i + 1));
            mr_images.push_back(std::move(mr));
        }
 
        // Store MR images
        for (const auto& image : mr_images) {
            REQUIRE(store_to_pacs(image, "127.0.0.1", port, server.ae_title(), "MR_SCANNER"));
        }
 
        // Step 4: Verify data consistency
        auto verifier = server.get_verifier();
 
        // Verify patient exists
        REQUIRE(verifier.verify_patient_exists(patient_id));
 
        // Verify study contains both modalities
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"CT", "MR"}));
 
        // Verify series count (1 CT + 1 MR = 2 series)
        REQUIRE(verifier.verify_series_count(study_uid, 2));
 
        // Verify image counts
        REQUIRE(verifier.verify_image_count(ct_series_uid, 3));
        REQUIRE(verifier.verify_image_count(mr_series_uid, 2));
 
        // Verify no duplicate UIDs
        REQUIRE(verifier.verify_unique_uids(study_uid));
 
        // Verify total stored count
        REQUIRE(server.stored_count() == 5);
        REQUIRE(server.error_count() == 0);
    }
 
    SECTION("Scenario 2: Interventional workflow - XA cine acquisition") {
        // This scenario simulates an interventional radiology procedure
        // Workflow: XA cine acquisition → Store multi-frame → Query verification
 
        const std::string patient_id = "INTERVENT001";
        const std::string patient_name = "INTERVENTIONAL^PATIENT";
        auto study_uid = generate_uid();
 
        // Generate XA cine (multi-frame)
        auto xa_cine = test_data_generator::xa_cine(10, study_uid);  // 10 frames
        xa_cine.set_string(tags::patient_id, vr_type::LO, patient_id);
        xa_cine.set_string(tags::patient_name, vr_type::PN, patient_name);
        xa_cine.set_string(tags::series_description, vr_type::LO, "Coronary Angiography Run 1");
 
        auto xa_series_uid_opt = xa_cine.get_string(tags::series_instance_uid);
        REQUIRE(!xa_series_uid_opt.empty());
        auto xa_series_uid = std::string(xa_series_uid_opt);
 
        // Store XA cine
        REQUIRE(store_to_pacs(xa_cine, "127.0.0.1", port, server.ae_title(), "XA_CATH_LAB"));
 
        // Generate second XA run
        auto xa_cine_2 = test_data_generator::xa_cine(15, study_uid);  // 15 frames
        xa_cine_2.set_string(tags::patient_id, vr_type::LO, patient_id);
        xa_cine_2.set_string(tags::patient_name, vr_type::PN, patient_name);
        xa_cine_2.set_string(tags::series_description, vr_type::LO, "Coronary Angiography Run 2");
 
        // Store second run
        REQUIRE(store_to_pacs(xa_cine_2, "127.0.0.1", port, server.ae_title(), "XA_CATH_LAB"));
 
        // Verify data consistency
        auto verifier = server.get_verifier();
 
        REQUIRE(verifier.verify_patient_exists(patient_id));
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"XA"}));
        REQUIRE(verifier.verify_series_count(study_uid, 2));  // 2 XA runs
        REQUIRE(verifier.verify_unique_uids(study_uid));
    }
 
    SECTION("Scenario 3: Emergency multi-modality - Trauma workflow") {
        // This scenario simulates emergency trauma imaging
        // Workflow: Rapid CT → XA intervention → Follow-up CT (all in same study)
 
        const std::string patient_id = "TRAUMA001";
        const std::string patient_name = "TRAUMA^PATIENT^EMERGENCY";
        auto study_uid = generate_uid();
 
        // Step 1: Initial trauma CT
        auto initial_ct_series = generate_uid();
        for (int i = 0; i < 5; ++i) {
            auto ct = test_data_generator::ct(study_uid);
            ct.set_string(tags::patient_id, vr_type::LO, patient_id);
            ct.set_string(tags::patient_name, vr_type::PN, patient_name);
            ct.set_string(tags::series_instance_uid, vr_type::UI, initial_ct_series);
            ct.set_string(tags::series_description, vr_type::LO, "Initial Trauma CT");
            ct.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
            REQUIRE(store_to_pacs(ct, "127.0.0.1", port, server.ae_title(), "CT_EMERGENCY"));
        }
 
        // Step 2: XA intervention
        auto xa_intervention = test_data_generator::xa_cine(20, study_uid);
        xa_intervention.set_string(tags::patient_id, vr_type::LO, patient_id);
        xa_intervention.set_string(tags::patient_name, vr_type::PN, patient_name);
        xa_intervention.set_string(tags::series_description, vr_type::LO, "Emergency Embolization");
        REQUIRE(store_to_pacs(xa_intervention, "127.0.0.1", port, server.ae_title(), "XA_EMERGENCY"));
 
        // Step 3: Follow-up CT
        auto followup_ct_series = generate_uid();
        for (int i = 0; i < 3; ++i) {
            auto ct = test_data_generator::ct(study_uid);
            ct.set_string(tags::patient_id, vr_type::LO, patient_id);
            ct.set_string(tags::patient_name, vr_type::PN, patient_name);
            ct.set_string(tags::series_instance_uid, vr_type::UI, followup_ct_series);
            ct.set_string(tags::series_description, vr_type::LO, "Follow-up CT");
            ct.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
            REQUIRE(store_to_pacs(ct, "127.0.0.1", port, server.ae_title(), "CT_EMERGENCY"));
        }
 
        // Verify complete trauma workflow
        auto verifier = server.get_verifier();
 
        REQUIRE(verifier.verify_patient_exists(patient_id));
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"CT", "XA"}));
        REQUIRE(verifier.verify_series_count(study_uid, 3));  // 2 CT series + 1 XA
        REQUIRE(verifier.verify_image_count(initial_ct_series, 5));
        REQUIRE(verifier.verify_image_count(followup_ct_series, 3));
        REQUIRE(verifier.verify_unique_uids(study_uid));
 
        // Verify total instance count
        size_t total_instances = verifier.get_instance_count(study_uid);
        REQUIRE(total_instances == 9);  // 5 + 1 + 3
    }
 
    SECTION("Scenario 4: Concurrent modality operations") {
        // This scenario tests multiple scanners storing simultaneously
        // Tests thread safety and data integrity under concurrent load
 
        const std::string study_uid = generate_uid();
        const std::string patient_id = "CONCURRENT001";
        const std::string patient_name = "CONCURRENT^PATIENT";
 
        std::vector<dicom_dataset> all_datasets;
        std::vector<std::string> series_uids;
 
        // Generate datasets for 4 different modalities
        const std::vector<std::pair<std::string, int>> modality_counts = {
            {"CT", 5},
            {"MR", 4},
            {"XA", 2},
            {"US", 3}
        };
 
        for (const auto& [modality, count] : modality_counts) {
            auto series_uid = generate_uid();
            series_uids.push_back(series_uid);
 
            for (int i = 0; i < count; ++i) {
                dicom_dataset ds;
                if (modality == "CT") {
                    ds = test_data_generator::ct(study_uid);
                } else if (modality == "MR") {
                    ds = test_data_generator::mr(study_uid);
                } else if (modality == "XA") {
                    ds = test_data_generator::xa(study_uid);
                } else if (modality == "US") {
                    ds = test_data_generator::us(study_uid);
                }
 
                ds.set_string(tags::patient_id, vr_type::LO, patient_id);
                ds.set_string(tags::patient_name, vr_type::PN, patient_name);
                ds.set_string(tags::series_instance_uid, vr_type::UI, series_uid);
                ds.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
                all_datasets.push_back(std::move(ds));
            }
        }
 
        // Store all datasets in parallel
        size_t success = parallel_store(server, all_datasets);
 
        // Allow time for indexing
        std::this_thread::sleep_for(std::chrono::milliseconds{100});
 
        // Verify all stores succeeded
        REQUIRE(success == all_datasets.size());
 
        // Verify data consistency
        auto verifier = server.get_verifier();
 
        REQUIRE(verifier.verify_patient_exists(patient_id));
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"CT", "MR", "XA", "US"}));
        REQUIRE(verifier.verify_series_count(study_uid, 4));
        REQUIRE(verifier.verify_unique_uids(study_uid));
 
        // Verify no errors
        REQUIRE(server.error_count() == 0);
 
        // Verify total stored
        size_t expected_total = 5 + 4 + 2 + 3;  // 14 images
        REQUIRE(verifier.get_instance_count(study_uid) == expected_total);
    }
 
    server.stop();
}

References kcenon::pacs::integration_test::test_data_generator::ct(), kcenon::pacs::services::ct, kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::services::image, kcenon::pacs::integration_test::test_data_generator::mr(), kcenon::pacs::services::mr, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::network::success, kcenon::pacs::integration_test::test_data_generator::us(), kcenon::pacs::integration_test::test_data_generator::worklist(), kcenon::pacs::integration_test::test_data_generator::xa(), and kcenon::pacs::integration_test::test_data_generator::xa_cine().

Here is the call graph for this function:

TEST_CASE() [2/3]

TEST_CASE	(	"Multi-modal workflow with MPPS tracking"	,
		""	[workflow][mpps][integration] )

Definition at line 822 of file test_multimodal_workflow.cpp.

                                                                                      {
    auto port = find_available_port();
    multimodal_pacs_server server(port);
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    SECTION("MPPS lifecycle for multi-modality study") {
        const std::string patient_id = "MPPS001";
        const std::string patient_name = "MPPS^TRACKING^PATIENT";
        auto study_uid = generate_uid();
 
        // Add worklist items for CT and MR
        auto ct_worklist = test_data_generator::worklist(patient_id, "CT");
        ct_worklist.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
        server.add_worklist_item(ct_worklist);
 
        auto mr_worklist = test_data_generator::worklist(patient_id, "MR");
        mr_worklist.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
        server.add_worklist_item(mr_worklist);
 
        // Perform CT and store images
        auto ct = test_data_generator::ct(study_uid);
        ct.set_string(tags::patient_id, vr_type::LO, patient_id);
        ct.set_string(tags::patient_name, vr_type::PN, patient_name);
        REQUIRE(store_to_pacs(ct, "127.0.0.1", port, server.ae_title(), "CT_SCANNER"));
 
        // Perform MR and store images
        auto mr = test_data_generator::mr(study_uid);
        mr.set_string(tags::patient_id, vr_type::LO, patient_id);
        mr.set_string(tags::patient_name, vr_type::PN, patient_name);
        REQUIRE(store_to_pacs(mr, "127.0.0.1", port, server.ae_title(), "MR_SCANNER"));
 
        // Verify data consistency
        auto verifier = server.get_verifier();
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"CT", "MR"}));
        REQUIRE(verifier.verify_unique_uids(study_uid));
        REQUIRE(server.stored_count() == 2);
    }
 
    server.stop();
}

References kcenon::pacs::integration_test::test_data_generator::ct(), kcenon::pacs::services::ct, kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::integration_test::test_data_generator::mr(), kcenon::pacs::services::mr, and kcenon::pacs::integration_test::test_data_generator::worklist().

Here is the call graph for this function:

TEST_CASE() [3/3]

TEST_CASE	(	"Stress test: High-volume multi-modal storage"	,
		""	[workflow][.stress][integration] )

Definition at line 864 of file test_multimodal_workflow.cpp.

                      : High-volume multi-modal storage", "[workflow][.stress][integration]") {
    auto port = find_available_port();
    multimodal_pacs_server server(port);
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    SECTION("Store 8 images from multiple modalities sequentially") {
        const std::string study_uid = generate_uid();
        const std::string patient_id = "STRESS001";
        const std::string patient_name = "STRESS^TEST^PATIENT";
 
        // Store 8 images sequentially across 4 modalities (2 each)
        const std::vector<std::string> modalities = {"CT", "MR", "XA", "US"};
        size_t success_count = 0;
 
        auto start = std::chrono::steady_clock::now();
 
        for (int i = 0; i < 8; ++i) {
            const auto& modality = modalities[i % modalities.size()];
            dicom_dataset ds;
 
            if (modality == "CT") {
                ds = test_data_generator::ct(study_uid);
            } else if (modality == "MR") {
                ds = test_data_generator::mr(study_uid);
            } else if (modality == "XA") {
                ds = test_data_generator::xa(study_uid);
            } else {
                ds = test_data_generator::us(study_uid);
            }
 
            ds.set_string(tags::patient_id, vr_type::LO, patient_id);
            ds.set_string(tags::patient_name, vr_type::PN, patient_name);
            ds.set_string(tags::sop_instance_uid, vr_type::UI, generate_uid());
 
            if (store_to_pacs(ds, "127.0.0.1", port, server.ae_title(), "STRESS_SCU")) {
                ++success_count;
            }
        }
 
        auto duration = std::chrono::steady_clock::now() - start;
 
        INFO("Stored " << success_count << " images in "
             << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() << "ms");
 
        // Verify all stores succeeded
        REQUIRE(success_count == 8);
 
        // Verify no data corruption
        auto verifier = server.get_verifier();
        REQUIRE(verifier.verify_unique_uids(study_uid));
        REQUIRE(verifier.verify_modalities_in_study(study_uid, {"CT", "MR", "XA", "US"}));
    }
 
    server.stop();
}

References kcenon::pacs::integration_test::test_data_generator::ct(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::integration_test::test_data_generator::mr(), kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::integration_test::test_data_generator::us(), and kcenon::pacs::integration_test::test_data_generator::xa().

Here is the call graph for this function: