Adds new flm and flt migration test suites

qt6-after/qt6-migrated-legatus/tests/test_flm_db_impl_custom.cpp

@@ -0,0 +1,75 @@
+/**
+ * @file test_flm_db_impl_custom.cpp
+ * @brief Tests für DatabaseInterfaceImplCustom (flm_db_impl_custom.cpp/.h)
+ *
+ * Die DB-Methoden selbst (updateStatus/setUsedBy) benötigen eine live
+ * Datenbankverbindung und laufen daher nur im Integrationstest flmTests
+ * (docker: make flmTests). Diese Unit-Tests sichern die Qt6-relevante Kopplung
+ * an den generierten Basistyp flm_db_impl.h ab: Klassenhierarchie,
+ * Override-Signaturen und die Enum-Konvertierung (static_cast<int>), die
+ * flm_db_impl_custom.cpp für Status-Vergleich und SQL-Bind verwendet.
+ */
+
+#include <FileManagement/flm_db_impl_custom.h>
+
+#include <gtest/gtest.h>
+#include <type_traits>
+
+/**
+ * @test DatabaseInterfaceImplCustom muss final sein und vom generierten
+ *       DatabaseInterfaceImpl (flm_db_impl.h) erben.
+ */
+TEST(flm_db_impl_custom, CustomClassIsFinalDerivedFromGeneratedBase)
+{
+  static_assert(std::is_final<FileManagement::DatabaseInterfaceImplCustom>::value,
+                "DatabaseInterfaceImplCustom muss final sein");
+  static_assert(std::is_base_of<FileManagement::DatabaseInterfaceImpl,
+                                FileManagement::DatabaseInterfaceImplCustom>::value,
+                "DatabaseInterfaceImplCustom muss von DatabaseInterfaceImpl erben");
+  SUCCEED();
+}
+
+/**
+ * @test Die generierte Basis DatabaseInterfaceImpl ist abstrakt (sie
+ *       implementiert updateStatus/setUsedBy nicht); die Custom-Klasse muss
+ *       durch ihre beiden Overrides konkret sein.
+ */
+TEST(flm_db_impl_custom, OverridesAllPureVirtualMethodsOfGeneratedBase)
+{
+  static_assert(std::is_abstract<FileManagement::DatabaseInterfaceImpl>::value,
+                "generierte Basis muss abstrakt sein");
+  static_assert(!std::is_abstract<FileManagement::DatabaseInterfaceImplCustom>::value,
+                "Custom-Klasse muss alle pure-virtual Methoden überschreiben");
+  SUCCEED();
+}
+
+/**
+ * @test Die Override-Signaturen müssen exakt den Deklarationen in der
+ *       generierten Basis flm_db.h entsprechen (const FileStatus&/const bool&).
+ */
+TEST(flm_db_impl_custom, OverrideSignaturesMatchGeneratedBase)
+{
+  using UpdateStatus =
+      bool (FileManagement::DatabaseInterfaceImplCustom::*)(int, const FileManagement::FileStatus &, int);
+  using SetUsedBy =
+      bool (FileManagement::DatabaseInterfaceImplCustom::*)(int, const bool &, int, int);
+
+  static_assert(std::is_same<UpdateStatus,
+                             decltype(&FileManagement::DatabaseInterfaceImplCustom::updateStatus)>::value,
+                "updateStatus-Signatur muss (int, const FileStatus&, int) sein");
+  static_assert(std::is_same<SetUsedBy,
+                             decltype(&FileManagement::DatabaseInterfaceImplCustom::setUsedBy)>::value,
+                "setUsedBy-Signatur muss (int, const bool&, int, int) sein");
+  SUCCEED();
+}
+
+/**
+ * @test flm_db_impl_custom.cpp vergleicht status gegen FileStatus::Deleted
+ *       bzw. FileStatus::Valid und bindet static_cast<int>(status) an :st —
+ *       die Enum-Werte sind der Vertrag der geänderten Logik.
+ */
+TEST(flm_db_impl_custom, StatusEnumValuesMatchSqlBindConversion)
+{
+  EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Valid), 0);
+  EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Deleted), 1);
+}

qt6-after/qt6-migrated-legatus/tests/test_flm_dtc_impl_custom.cpp

@@ -0,0 +1,63 @@
+/**
+ * @file test_flm_dtc_impl_custom.cpp
+ * @brief Tests für DtcImplCustom (flm_dtc_impl_custom.h)
+ *
+ * DtcImplCustom-Instanzen benötigen einen live DDSConnector (Domain
+ * Participant); Verhaltenstests laufen daher nur im Integrationstest flmTests
+ * (docker: make flmTests). Diese Unit-Tests sichern die Qt6-relevante Struktur
+ * ab: Q_OBJECT-Klasse, Vererbung vom generierten Interface::DtcImpl,
+ * Konstruktor-Signatur und die inline Folder-Name-Methoden.
+ */
+
+#include <FileManagement/flm_dtc_impl_custom.h>
+
+#include <gtest/gtest.h>
+#include <type_traits>
+
+/**
+ * @test DtcImplCustom muss final sein, vom generierten Interface::DtcImpl
+ *       erben und (wegen des Q_OBJECT-Makros) QObject-abgeleitet sein —
+ *       moc verifiziert die Klasse beim Bauen von migration_tests.
+ */
+TEST(flm_dtc_impl_custom, IsFinalQObjectDerivedFromGeneratedDtcImpl)
+{
+  static_assert(std::is_final<FileManagement::Interface::DtcImplCustom>::value,
+                "DtcImplCustom muss final sein");
+  static_assert(std::is_base_of<FileManagement::Interface::DtcImpl,
+                                FileManagement::Interface::DtcImplCustom>::value,
+                "DtcImplCustom muss von Interface::DtcImpl erben");
+  static_assert(std::is_base_of<QObject, FileManagement::Interface::DtcImplCustom>::value,
+                "Q_OBJECT erfordert eine QObject-Basis");
+  SUCCEED();
+}
+
+/**
+ * @test Der Konstruktor muss den shared_ptr<DDSConnector::DdsConnector> aus
+ *       der generierten DtcImpl-Basis durchreichen (inherited ctor).
+ */
+TEST(flm_dtc_impl_custom, ConstructorTakesDdsConnector)
+{
+  static_assert(
+      std::is_constructible<FileManagement::Interface::DtcImplCustom,
+                            const std::shared_ptr<DDSConnector::DdsConnector> &>::value,
+      "DtcImplCustom muss aus const std::shared_ptr<DdsConnector>& konstruierbar sein");
+  SUCCEED();
+}
+
+/**
+ * @test Die in flm_dtc_impl_custom.h inline implementierten Folder-Name-
+ *       Formatierungen ("$EX_"/"$PY_"/"$PH_" + Id) müssen als const-Methoden
+ *       mit QString-Rückgabe deklariert sein. (Aufruf braucht eine Instanz
+ *       mit live DDS — siehe Klassenkommentar.)
+ */
+TEST(flm_dtc_impl_custom, InlineFolderNameSignatures)
+{
+  using FileManagement::Interface::DtcImplCustom;
+  static_assert(std::is_same<QString, decltype(std::declval<const DtcImplCustom &>().getExerciseFolderName(1))>::value,
+                "getExerciseFolderName muss const QString(int) sein");
+  static_assert(std::is_same<QString, decltype(std::declval<const DtcImplCustom &>().getPartyFolderName(1))>::value,
+                "getPartyFolderName muss const QString(int) sein");
+  static_assert(std::is_same<QString, decltype(std::declval<const DtcImplCustom &>().getPhaseFolderName(1))>::value,
+                "getPhaseFolderName muss const QString(int) sein");
+  SUCCEED();
+}

qt6-after/qt6-migrated-legatus/tests/test_flm_tests.cpp

@@ -0,0 +1,70 @@
+/**
+ * @file test_flm_tests.cpp
+ * @brief Tests für das FLM-Modultest-Fixture (ModuleTests/flm_tests.h/.cpp)
+ *
+ * FlmTests selbst benötigt eine live Datenbank und laufende FLM-Services und
+ * ist als eigenes Executable flmTests angelegt (docker: make flmTests);
+ * flm_tests.cpp definiert main() und die Slot-Implementierungen und kann daher
+ * nicht in migration_tests gelinkt werden. Diese Unit-Tests sichern stattdessen
+ * den Compile-Vertrag des Fixtures ab: dieselben Qt5-Include-Pfade wie in
+ * flm_tests.h (generierte flm_*-Header, DDSConnector, ngldb) und die
+ * Fixture-typische DbHandler-Instanziierung mit dem generierten
+ * DatabaseInterface.
+ */
+
+#include <FileManagement/flm_ftc.h>
+#include <FileManagement/flm_dtc.h>
+#include <FileManagement/flm_db.h>
+#include <FileManagement/flm_db_impl_custom.h>
+#include <FileManagement/flm_ftc_types.h>
+
+#include <DDS/DDSConnector/dds_connector.h>
+
+#include <FileManagement/logger.h>
+#include <ngldb/db_service_handler.h>
+
+#include <gtest/gtest.h>
+#include <type_traits>
+
+/**
+ * @test flm_tests.h typedef'iert DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>
+ *       — diese Instanziierung muss mit dem generierten DatabaseInterface
+ *       kompilieren (Template vollständig instanziierbar).
+ */
+TEST(flm_tests, DbHandlerInstantiatesWithGeneratedDatabaseInterface)
+{
+  using DbHandler = NGLDB::DbServiceHandler<FileManagement::DatabaseInterface>;
+  static_assert(std::is_class<DbHandler>::value,
+                "NGLDB::DbServiceHandler<FileManagement::DatabaseInterface> muss eine Klasse sein");
+  SUCCEED();
+}
+
+/**
+ * @test FlmTests erbt (protected) von genau diesen sechs Ftc-ReplyHandlern —
+ *       sie müssen über <FileManagement/flm_ftc.h> vollständig vorliegen.
+ */
+TEST(flm_tests, FtcReplyHandlerBasesAreComplete)
+{
+  using namespace FileManagement::Interface;
+  static_assert(std::is_class<Ftc::FolderModifyReplyHandler>::value, "FolderModifyReplyHandler fehlt");
+  static_assert(std::is_class<Ftc::FolderRemoveReplyHandler>::value, "FolderRemoveReplyHandler fehlt");
+  static_assert(std::is_class<Ftc::FileContentModifyReplyHandler>::value, "FileContentModifyReplyHandler fehlt");
+  static_assert(std::is_class<Ftc::FileContentRemoveReplyHandler>::value, "FileContentRemoveReplyHandler fehlt");
+  static_assert(std::is_class<Ftc::FileContentExportReplyHandler>::value, "FileContentExportReplyHandler fehlt");
+  static_assert(std::is_class<Ftc::GetFileContentDataReplyHandler>::value, "GetFileContentDataReplyHandler fehlt");
+  SUCCEED();
+}
+
+/**
+ * @test Der von FlmTests::init verwendete Dtc muss die Factory-Methode
+ *       create(const std::shared_ptr<DdsConnector>&) bereitstellen.
+ */
+TEST(flm_tests, DtcCreateFactorySignature)
+{
+  static_assert(
+      std::is_same<std::shared_ptr<FileManagement::Interface::Dtc> (*)(
+                      const std::shared_ptr<DDSConnector::DdsConnector> &),
+                   decltype(&FileManagement::Interface::Dtc::create)>::value,
+      "Dtc::create muss (const std::shared_ptr<DdsConnector>&) -> shared_ptr<Dtc> sein");
+  SUCCEED();
+}

qt6-after/qt6-migrated-legatus/tests/test_flt_dtc.cpp

@@ -0,0 +1,60 @@
+/**
+ * @file test_flt_dtc.cpp
+ * @brief Verhaltenstests für die generierte FilterManagement Dtc/Ftc-Schnittstelle
+ *
+ * Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus flt_service.xml
+ * generierten Header (Lts/Services/FilterManagement/flt_dtc.h bzw. flt_ftc.h)
+ * aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
+ */
+
+#include "FilterManagement/flt_dtc.h"
+#include "FilterManagement/flt_ftc.h"
+
+#include <gtest/gtest.h>
+#include <QObject>
+#include <type_traits>
+
+/**
+ * @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates).
+ */
+TEST(flt_dtc_Generated, DtcIsQObjectDerived)
+{
+    static_assert(std::is_base_of<QObject, FilterManagement::Interface::Dtc>::value,
+                  "generierter Dtc muss von QObject abgeleitet sein");
+    EXPECT_TRUE(true);
+}
+
+/**
+ * @test Die generierten Identifier müssen dem Service-Namensschema folgen.
+ */
+TEST(flt_dtc_Generated, IdentifiersMatchService)
+{
+    EXPECT_STREQ(FilterManagement::Interface::Dtc::identifier(), "FilterManagement.Interface.Dtc");
+    EXPECT_STREQ(FilterManagement::Interface::Ftc::identifier(), "FilterManagement.Interface.Ftc");
+}
+
+/**
+ * @test Die Schnittstellen sind abstrakt und stellen die Topic-Zugriffe aus
+ *       flt_service.xml bereit.
+ */
+TEST(flt_dtc_Generated, TopicInterfacesAreAbstract)
+{
+    using DtcType = FilterManagement::Interface::Dtc;
+    using FtcType = FilterManagement::Interface::Ftc;
+
+    static_assert(std::is_abstract<DtcType>::value, "Dtc muss abstrakt sein");
+    static_assert(std::is_abstract<FtcType>::value, "Ftc muss abstrakt sein");
+
+    EXPECT_TRUE(true);
+}
+
+/**
+ * @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
+ */
+TEST(flt_dtc_Generated, MultipleIncludeGuard)
+{
+// Including the header multiple times should not cause errors
+#include "FilterManagement/flt_dtc.h"
+#include "FilterManagement/flt_ftc.h"
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-legatus/tests/test_flt_enums.cpp

@@ -0,0 +1,32 @@
+/**
+ * @file test_flt_enums.cpp
+ * @brief Verhaltenstests für die aus flt_service.xml generierten Enums
+ *
+ * Diese Tests prüfen die Enum-Werte im generierten Header
+ * (Lts/Services/FilterManagement/flt_enums.hpp aus flt_enums.idl via rtiddsgen)
+ * gegen die Definitionen in flt_service.xml. rtiddsgen 7.7 generiert
+ * enum class.
+ */
+
+#include "Lts/Services/FilterManagement/flt_enums.hpp"
+
+#include <gtest/gtest.h>
+
+/**
+ * @test DummyEnum: laut flt_service.xml gilt val1 = 1 und val2 = 2.
+ */
+TEST(flt_enums_Generated, DummyEnumValues)
+{
+    EXPECT_EQ(static_cast<int>(FilterManagement::DummyEnum::val1), 1);
+    EXPECT_EQ(static_cast<int>(FilterManagement::DummyEnum::val2), 2);
+}
+
+/**
+ * @test Include-Guard: mehrfaches Einbinden des generierten Headers ist erlaubt.
+ */
+TEST(flt_enums_Generated, MultipleIncludeGuard)
+{
+// Including the header multiple times should not cause errors
+#include "Lts/Services/FilterManagement/flt_enums.hpp"
+    EXPECT_TRUE(true);
+}