Test/writer test matrix3d size (#106)

* check that dir exists in writer and Matrix3d is in bounds

* formatting

* formatting again

* fixed includes

Author: aclark29

src/data_ops/writer.cpp

@@ -4,8 +4,8 @@
 // Created Date: 2025-01-17                                                   //
 // Author: Matthew Carroll                                                    //
 // -----                                                                      //
-// Last Modified: 2025-06-05                                                  //
-// Modified By: Matthew Carroll                                               //
+// Last Modified: 2025-07-24                                                  //
+// Modified By: Andrew Clark                                                  //
 // -----                                                                      //
 // Copyright (c) 2025 Syndemics Lab at Boston Medical Center                  //
 ////////////////////////////////////////////////////////////////////////////////
@@ -237,6 +237,17 @@ std::string WriterImpl::WriteTimedMatrix3d(
                     index[static_cast<int>(Dimension::kIntervention)] = i;
                     index[static_cast<int>(Dimension::kOud)] = b;
                     index[static_cast<int>(Dimension::kDemographicCombo)] = d;
+                    const auto &dims = kv.second.dimensions();
+                    if (index[0] >= dims[0] || index[1] >= dims[1] ||
+                        index[2] >= dims[2]) {
+                        std::stringstream msg;
+                        msg << "Out of bounds matrix access at: [" << kv.first
+                            << ", " << "(" << i << ", " << b << ", " << d
+                            << ")]";
+                        respond::utils::LogError(logger_name, msg.str());
+                        throw std::runtime_error(
+                            "Out of bounds Matrix3d access.");
+                    }
                     double value = kv.second(index[0], index[1], index[2]);
                     if (pivot) {
                         stream << interventions[i] << "," << behaviors[b] << ","
@@ -526,8 +537,15 @@ std::string WriterImpl::WriteContents(std::stringstream &stream,
                                       const std::string &path,
                                       OutputType output_type) const {
     if (output_type == OutputType::kFile) {
-        std::filesystem::path p = (path.empty()) ? "temp.csv" : path;
         try {
+            std::filesystem::path p = (path.empty()) ? "temp.csv" : path;
+            std::filesystem::path dir = p.parent_path();
+            if (!dir.empty() && !std::filesystem::exists(dir)) {
+                respond::utils::LogWarning(
+                    logger_name, "Unable to write contents, directory: " +
+                                     dir.string() + " does not exist...");
+                throw std::invalid_argument("Directory does not exist.");
+            }
             std::ofstream file(p.string());
             file << stream.rdbuf();
             file.close();

tests/src/writer_test.cpp

@@ -4,8 +4,8 @@
 // Created Date: 2025-01-14                                                   //
 // Author: Matthew Carroll                                                    //
 // -----                                                                      //
-// Last Modified: 2025-06-06                                                  //
-// Modified By: Matthew Carroll                                               //
+// Last Modified: 2025-07-24                                                  //
+// Modified By: Andrew Clark                                                  //
 // -----                                                                      //
 // Copyright (c) 2025 Syndemics Lab at Boston Medical Center                  //
 ////////////////////////////////////////////////////////////////////////////////
@@ -246,3 +246,54 @@ TEST_F(WriterTest, WriteTotalsData) {
         writer->WriteTotalsData(totals, "", OutputType::kString);
     ASSERT_EQ(expected, result);
 }
+
+TEST_F(WriterTest, WriteTimedMatrix3dOutOfBoundsMatrixAccess) {
+    TimedMatrix3d utilities;
+    Matrix3d mat3d(1, 1, 1);
+    mat3d.setConstant(0.9);
+    utilities[0] = mat3d;
+
+    ASSERT_THROW(writer->WriteUtilityData(utilities, "", OutputType::kString),
+                 std::runtime_error);
+}
+
+TEST_F(WriterTest, WriteDirectoryDoesNotExist) {
+    std::string fake_dir = "FakeDir";
+    std::string expected = "failure\n\nfailure\n\nfailure\n\n"
+                           "failure\n\nfailure";
+
+    MockDataLoader data_loader;
+    Matrix3d behavior(9, 16, 1);
+    behavior.setConstant(0.9);
+
+    Matrix3d intervention(81, 4, 1);
+    intervention.setConstant(0.8);
+
+    Matrix3d standard(9, 4, 1);
+    standard.setConstant(0.7);
+
+    // WriteOUDTransitionRates
+    EXPECT_CALL(data_loader, GetOUDTransitionRates())
+        .WillRepeatedly(Return(behavior));
+
+    // WriteInterventionTransitionRates
+    EXPECT_CALL(data_loader, GetInterventionTransitionRates(_))
+        .WillRepeatedly(Return(intervention));
+
+    // WriteInterventionInitRates
+    EXPECT_CALL(data_loader, GetInterventionInitRates())
+        .WillRepeatedly(Return(behavior));
+
+    // WriteOverdoseRates
+    EXPECT_CALL(data_loader, GetOverdoseRates(_))
+        .WillRepeatedly(Return(standard));
+
+    // WriteFatalOverdoseRates
+    EXPECT_CALL(data_loader, GetFatalOverdoseRates(_))
+        .WillRepeatedly(Return(standard));
+
+    std::string result =
+        writer->WriteInputData(data_loader, fake_dir, OutputType::kFile);
+
+    ASSERT_EQ(expected, result);
+}