Implement LogMessagePage

2025-09-26 01:32:24 +09:00
parent 963e9133c4
commit 5ea69f7e19
25 changed files with 2500 additions and 355 deletions
--- a/vav2/Vav2Player/Vav2UnitTest/tests/LogManagerTest.cpp
+++ b/vav2/Vav2Player/Vav2UnitTest/tests/LogManagerTest.cpp
@@ -0,0 +1,190 @@
+#include "pch.h"
+#include "../../Vav2Player/src/Logger/ILogManager.h"
+#include "../../Vav2Player/src/Logger/LogManager.h"
+#include "MockLogManager.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace Vav2Player;
+
+namespace Vav2PlayerUnitTests
+{
+    TEST_CLASS(LogManagerTest)
+    {
+    public:
+        TEST_METHOD_INITIALIZE(SetUp)
+        {
+            // Reset LogManagerProvider to default state before each test
+            LogManagerProvider::ResetToDefault();
+        }
+
+        TEST_METHOD_CLEANUP(TearDown)
+        {
+            // Clean up after each test
+            LogManagerProvider::ResetToDefault();
+        }
+
+        TEST_METHOD(LogManagerProvider_DefaultInstance_ShouldReturnSingleton)
+        {
+            // Act
+            ILogManager& instance1 = LogManagerProvider::GetInstance();
+            ILogManager& instance2 = LogManagerProvider::GetInstance();
+
+            // Assert
+            Assert::IsFalse(LogManagerProvider::IsCustomInstanceSet());
+            Assert::IsTrue(&instance1 == &instance2); // Same instance
+        }
+
+        TEST_METHOD(LogManagerProvider_CustomInstance_ShouldReturnMockInstance)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+
+            // Act
+            LogManagerProvider::SetInstance(mockLogManager);
+            ILogManager& instance = LogManagerProvider::GetInstance();
+
+            // Assert
+            Assert::IsTrue(LogManagerProvider::IsCustomInstanceSet());
+            Assert::IsTrue(static_cast<ILogManager*>(mockLogManager.get()) == &instance);
+        }
+
+        TEST_METHOD(MockLogManager_LogInfo_ShouldRecordCall)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+            LogManagerProvider::SetInstance(mockLogManager);
+
+            // Act
+            LogManagerProvider::GetInstance().LogInfo(L"Test message", L"TestSource");
+
+            // Assert
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount());
+            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogInfo"));
+            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Test message"));
+
+            auto lastCall = mockLogManager->GetLastLogCall();
+            Assert::AreEqual(static_cast<int>(LogLevel::Info), static_cast<int>(lastCall.level));
+            Assert::AreEqual(L"Test message", lastCall.message.c_str());
+            Assert::AreEqual(L"TestSource", lastCall.source.c_str());
+        }
+
+        TEST_METHOD(MockLogManager_LogVideoLoad_ShouldRecordVideoCall)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+            LogManagerProvider::SetInstance(mockLogManager);
+
+            // Act
+            LogManagerProvider::GetInstance().LogVideoLoad(L"test_video.mp4", true);
+
+            // Assert
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount());
+            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogVideoLoad"));
+            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Successfully loaded"));
+
+            auto videoPlayerCalls = mockLogManager->GetLogCallsFromSource(L"VideoPlayer");
+            Assert::AreEqual(static_cast<size_t>(1), videoPlayerCalls.size());
+        }
+
+        TEST_METHOD(MockLogManager_MultipleLogCalls_ShouldRecordAll)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+            LogManagerProvider::SetInstance(mockLogManager);
+            ILogManager& logManager = LogManagerProvider::GetInstance();
+
+            // Act
+            logManager.LogDebug(L"Debug message", L"Source1");
+            logManager.LogInfo(L"Info message", L"Source2");
+            logManager.LogWarning(L"Warning message", L"Source3");
+            logManager.LogError(L"Error message", L"Source4");
+
+            // Assert
+            Assert::AreEqual(static_cast<size_t>(4), mockLogManager->GetLogCallCount());
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Debug));
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Info));
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Warning));
+            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Error));
+        }
+
+        TEST_METHOD(MockLogManager_ResetToDefault_ShouldUseSingleton)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+            LogManagerProvider::SetInstance(mockLogManager);
+            Assert::IsTrue(LogManagerProvider::IsCustomInstanceSet());
+
+            // Act
+            LogManagerProvider::ResetToDefault();
+
+            // Assert
+            Assert::IsFalse(LogManagerProvider::IsCustomInstanceSet());
+
+            // Should now use singleton
+            ILogManager& instance = LogManagerProvider::GetInstance();
+            Assert::IsTrue(static_cast<ILogManager*>(mockLogManager.get()) != &instance);
+        }
+    };
+
+    /// <summary>
+    /// Example of how to test components that use logging
+    /// </summary>
+    TEST_CLASS(ComponentWithLoggingTest)
+    {
+    private:
+        // Example component that uses logging
+        class TestComponent
+        {
+        public:
+            void DoSomething()
+            {
+                LogManagerProvider::GetInstance().LogInfo(L"DoSomething called", L"TestComponent");
+
+                // Simulate some work
+                bool success = ProcessData();
+
+                if (success)
+                {
+                    LogManagerProvider::GetInstance().LogVideoLoad(L"test.mp4", true);
+                }
+                else
+                {
+                    LogManagerProvider::GetInstance().LogError(L"Processing failed", L"TestComponent");
+                }
+            }
+
+        private:
+            bool ProcessData() { return true; } // Always succeed for test
+        };
+
+    public:
+        TEST_METHOD_INITIALIZE(SetUp)
+        {
+            LogManagerProvider::ResetToDefault();
+        }
+
+        TEST_METHOD_CLEANUP(TearDown)
+        {
+            LogManagerProvider::ResetToDefault();
+        }
+
+        TEST_METHOD(TestComponent_DoSomething_ShouldLogCorrectly)
+        {
+            // Arrange
+            auto mockLogManager = std::make_shared<MockLogManager>();
+            LogManagerProvider::SetInstance(mockLogManager);
+
+            TestComponent component;
+
+            // Act
+            component.DoSomething();
+
+            // Assert
+            Assert::AreEqual(static_cast<size_t>(2), mockLogManager->GetLogCallCount()); // LogInfo + LogVideoLoad
+            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogInfo"));
+            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogVideoLoad"));
+            Assert::IsTrue(mockLogManager->WasMessageLogged(L"DoSomething called"));
+            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Successfully loaded"));
+        }
+    };
+}