Add Google Test framework with serialization and database tests

- Integrate Google Test v1.14.0 via FetchContent
- Create tests directory with CMake configuration
- Add comprehensive serialization tests (13 test cases)
- Add database integration tests (14 test cases)
- Update Makefile with test target
- Add test documentation (tests/README.md)
- Update main README with testing instructions
- All 27 tests passing successfully

Co-authored-by: djeada <[email protected]>

CMakeLists.txt

@@ -91,11 +91,26 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 set(CMAKE_AUTOMOC ON)
 
+# ---- Google Test Setup ----
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  GIT_REPOSITORY https://github.com/google/googletest.git
+  GIT_TAG v1.14.0
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+# Enable testing
+enable_testing()
+
 # engine core moved under game; no separate engine subdir target
 add_subdirectory(render)
 add_subdirectory(game)
 add_subdirectory(ui)
 add_subdirectory(tools)
+add_subdirectory(tests)
 
 # ---- Translation support ----
 # Define default language (can be overridden with -DDEFAULT_LANG=de)

Makefile

@@ -189,10 +189,11 @@ dev: install build
 .PHONY: test
 test: build
 	@echo "$(BOLD)$(BLUE)Running tests...$(RESET)"
-	@if [ -f "$(BUILD_DIR)/tests" ]; then \
-		cd $(BUILD_DIR) && ./tests; \
+	@if [ -f "$(BUILD_DIR)/bin/standard_of_iron_tests" ]; then \
+		cd $(BUILD_DIR) && ./bin/standard_of_iron_tests; \
 	else \
-		echo "$(YELLOW)No tests found. Test suite not yet implemented.$(RESET)"; \
+		echo "$(RED)Test executable not found. Build may have failed.$(RESET)"; \
+		exit 1; \
 	fi
 
 # ---- Formatting: strip comments first, then format (strict) ----

README.md

@@ -100,6 +100,21 @@ make build
 make run
 ```
 
+### Testing
+```bash
+# Run all tests
+make test
+
+# Build tests only
+cd build && make standard_of_iron_tests
+
+# Run specific test suites
+./build/bin/standard_of_iron_tests --gtest_filter=SerializationTest.*
+./build/bin/standard_of_iron_tests --gtest_filter=SaveStorageTest.*
+```
+
+For more details on testing, see [tests/README.md](tests/README.md).
+
 ## Project Structure
 
 ```
@@ -123,6 +138,10 @@ make run
 │   ├── entity/            # Entity-specific renderers
 │   ├── geom/              # Geometry utilities (flags, arrows, selection)
 │   └── ground/            # Terrain rendering
+├── tests/                 # Unit and integration tests
+│   ├── core/              # Core engine tests (serialization)
+│   ├── db/                # Database tests (save/load)
+│   └── README.md          # Testing guide
 ├── assets/
 │   ├── shaders/           # GLSL shaders
 │   ├── maps/              # Level data (JSON)

tests/CMakeLists.txt

@@ -0,0 +1,36 @@
+# Test suite for Standard of Iron
+# Uses Google Test framework
+
+# Test executable
+add_executable(standard_of_iron_tests
+    core/serialization_test.cpp
+    db/save_storage_test.cpp
+)
+
+# Link against GTest, project libraries
+target_link_libraries(standard_of_iron_tests
+    PRIVATE
+        GTest::gtest_main
+        GTest::gmock
+        Qt${QT_VERSION_MAJOR}::Core
+        Qt${QT_VERSION_MAJOR}::Gui
+        Qt${QT_VERSION_MAJOR}::Sql
+        engine_core
+        game_systems
+)
+
+# Include directories
+target_include_directories(standard_of_iron_tests
+    PRIVATE
+        ${CMAKE_SOURCE_DIR}
+        ${CMAKE_SOURCE_DIR}/game
+)
+
+# Add tests to CTest
+include(GoogleTest)
+gtest_discover_tests(standard_of_iron_tests)
+
+# Set output directory
+set_target_properties(standard_of_iron_tests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
+)

tests/README.md

@@ -0,0 +1,181 @@
+# Standard of Iron - Test Suite
+
+This directory contains unit and integration tests for the Standard of Iron project using Google Test.
+
+## Structure
+
+```
+tests/
+├── core/              # Core engine tests
+│   └── serialization_test.cpp  # Entity/World serialization tests
+├── db/                # Database tests
+│   └── save_storage_test.cpp   # SQLite save/load tests
+└── CMakeLists.txt     # Test build configuration
+```
+
+## Running Tests
+
+### Build and Run All Tests
+```bash
+make test
+```
+
+### Run Tests Directly
+```bash
+cd build
+./bin/standard_of_iron_tests
+```
+
+### Run Specific Tests
+```bash
+# Run only serialization tests
+./bin/standard_of_iron_tests --gtest_filter=SerializationTest.*
+
+# Run only database tests
+./bin/standard_of_iron_tests --gtest_filter=SaveStorageTest.*
+
+# Run a specific test case
+./bin/standard_of_iron_tests --gtest_filter=SerializationTest.EntitySerializationBasic
+```
+
+### Verbose Output
+```bash
+./bin/standard_of_iron_tests --gtest_color=yes
+```
+
+## Test Categories
+
+### Core Serialization Tests (`core/serialization_test.cpp`)
+Tests for JSON serialization and deserialization of game objects:
+- **Entity serialization**: Basic entity save/load
+- **Component serialization**: Individual component types (Transform, Unit, Movement, Attack, etc.)
+- **Round-trip testing**: Serialize→Deserialize→Verify data integrity
+- **Edge cases**: Missing fields, malformed JSON, default values
+- **File I/O**: Save to file and load from file
+
+### Database Integration Tests (`db/save_storage_test.cpp`)
+Tests for SQLite-based save game storage:
+- **Initialization**: In-memory database setup
+- **Save/Load**: Store and retrieve save slots
+- **Schema management**: Database schema creation and validation
+- **Error handling**: Non-existent slots, constraint violations
+- **Complex data**: Large saves, complex metadata, special characters
+- **CRUD operations**: List, delete, and overwrite slots
+
+## Adding New Tests
+
+### 1. Create a New Test File
+```cpp
+#include <gtest/gtest.h>
+// Include necessary headers
+
+class MyFeatureTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        // Setup code
+    }
+
+    void TearDown() override {
+        // Cleanup code
+    }
+};
+
+TEST_F(MyFeatureTest, TestCase) {
+    // Test code
+    EXPECT_EQ(expected, actual);
+}
+```
+
+### 2. Add to CMakeLists.txt
+```cmake
+add_executable(standard_of_iron_tests
+    core/serialization_test.cpp
+    db/save_storage_test.cpp
+    your_category/your_test.cpp  # Add your test here
+)
+```
+
+### 3. Rebuild and Run
+```bash
+make test
+```
+
+## Test Conventions
+
+### Naming
+- Test suite names should match the class/feature being tested
+- Test case names should describe what is being tested
+- Use descriptive names: `TEST_F(SerializationTest, EntityDeserializationRoundTrip)`
+
+### Assertions
+- Use `EXPECT_*` for non-fatal assertions (test continues)
+- Use `ASSERT_*` for fatal assertions (test stops)
+- Common assertions:
+  - `EXPECT_EQ(a, b)` - equality
+  - `EXPECT_TRUE(condition)` - boolean true
+  - `EXPECT_FLOAT_EQ(a, b)` - floating-point equality
+  - `EXPECT_NE(a, b)` - not equal
+
+### Test Organization
+- Group related tests in the same test fixture
+- Use descriptive test names
+- Test one thing per test case
+- Keep tests independent
+
+## Dependencies
+
+The test suite uses:
+- **Google Test** (v1.14.0) - Testing framework
+- **Qt6/Qt5** - Core, Gui, SQL modules
+- **engine_core** - Core game engine library
+- **game_systems** - Game systems library
+
+## Continuous Integration
+
+Tests are automatically run in CI when:
+- Pull requests are created
+- Code is pushed to main branch
+- Release builds are created
+
+## Coverage
+
+Current test coverage focuses on:
+- ✅ Entity and component serialization
+- ✅ World serialization
+- ✅ SQLite save/load operations
+- ✅ Database CRUD operations
+- ✅ Error handling and edge cases
+
+Future coverage should include:
+- [ ] Terrain serialization
+- [ ] AI system testing
+- [ ] Combat system testing
+- [ ] Pathfinding tests
+- [ ] Production system tests
+
+## Troubleshooting
+
+### Tests Not Found
+If tests aren't being discovered:
+```bash
+rm -rf build
+make configure
+make build
+```
+
+### Database Lock Errors
+Tests use in-memory databases (`:memory:`), so file locks shouldn't occur. If they do:
+- Check for orphaned test processes
+- Restart your terminal
+
+### Qt-related Errors
+Ensure Qt development packages are installed:
+```bash
+make install  # Installs dependencies
+```
+
+## References
+
+- [Google Test Documentation](https://google.github.io/googletest/)
+- [Google Test Primer](https://google.github.io/googletest/primer.html)
+- [Google Test Advanced Guide](https://google.github.io/googletest/advanced.html)

tests/core/serialization_test.cpp

@@ -0,0 +1,390 @@
+#include <gtest/gtest.h>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QTemporaryFile>
+#include "core/entity.h"
+#include "core/world.h"
+#include "core/component.h"
+#include "core/serialization.h"
+#include "systems/nation_id.h"
+#include "units/spawn_type.h"
+#include "units/troop_type.h"
+
+using namespace Engine::Core;
+
+class SerializationTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        world = std::make_unique<World>();
+    }
+
+    void TearDown() override {
+        world.reset();
+    }
+
+    std::unique_ptr<World> world;
+};
+
+TEST_F(SerializationTest, EntitySerializationBasic) {
+    auto* entity = world->createEntity();
+    ASSERT_NE(entity, nullptr);
+    
+    auto entity_id = entity->getId();
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    EXPECT_TRUE(json.contains("id"));
+    EXPECT_EQ(json["id"].toVariant().toULongLong(), static_cast<qulonglong>(entity_id));
+}
+
+TEST_F(SerializationTest, TransformComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* transform = entity->addComponent<TransformComponent>();
+    
+    transform->position.x = 10.5F;
+    transform->position.y = 20.3F;
+    transform->position.z = 30.1F;
+    transform->rotation.x = 0.5F;
+    transform->rotation.y = 1.0F;
+    transform->rotation.z = 1.5F;
+    transform->scale.x = 2.0F;
+    transform->scale.y = 2.5F;
+    transform->scale.z = 3.0F;
+    transform->hasDesiredYaw = true;
+    transform->desiredYaw = 45.0F;
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("transform"));
+    QJsonObject transform_obj = json["transform"].toObject();
+    
+    EXPECT_FLOAT_EQ(transform_obj["posX"].toDouble(), 10.5);
+    EXPECT_FLOAT_EQ(transform_obj["posY"].toDouble(), 20.3);
+    EXPECT_FLOAT_EQ(transform_obj["posZ"].toDouble(), 30.1);
+    EXPECT_FLOAT_EQ(transform_obj["rotX"].toDouble(), 0.5);
+    EXPECT_FLOAT_EQ(transform_obj["rotY"].toDouble(), 1.0);
+    EXPECT_FLOAT_EQ(transform_obj["rotZ"].toDouble(), 1.5);
+    EXPECT_FLOAT_EQ(transform_obj["scale_x"].toDouble(), 2.0);
+    EXPECT_FLOAT_EQ(transform_obj["scaleY"].toDouble(), 2.5);
+    EXPECT_FLOAT_EQ(transform_obj["scale_z"].toDouble(), 3.0);
+    EXPECT_TRUE(transform_obj["hasDesiredYaw"].toBool());
+    EXPECT_FLOAT_EQ(transform_obj["desiredYaw"].toDouble(), 45.0);
+}
+
+TEST_F(SerializationTest, UnitComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* unit = entity->addComponent<UnitComponent>();
+    
+    unit->health = 80;
+    unit->max_health = 100;
+    unit->speed = 5.5F;
+    unit->vision_range = 15.0F;
+    unit->spawn_type = Game::Units::SpawnType::Archer;
+    unit->owner_id = 1;
+    unit->nation_id = Game::Systems::NationID::RomanRepublic;
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("unit"));
+    QJsonObject unit_obj = json["unit"].toObject();
+    
+    EXPECT_EQ(unit_obj["health"].toInt(), 80);
+    EXPECT_EQ(unit_obj["max_health"].toInt(), 100);
+    EXPECT_FLOAT_EQ(unit_obj["speed"].toDouble(), 5.5);
+    EXPECT_FLOAT_EQ(unit_obj["vision_range"].toDouble(), 15.0);
+    EXPECT_EQ(unit_obj["unit_type"].toString(), QString("archer"));
+    EXPECT_EQ(unit_obj["owner_id"].toInt(), 1);
+    EXPECT_EQ(unit_obj["nation_id"].toString(), QString("roman_republic"));
+}
+
+TEST_F(SerializationTest, MovementComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* movement = entity->addComponent<MovementComponent>();
+    
+    movement->hasTarget = true;
+    movement->target_x = 50.0F;
+    movement->target_y = 60.0F;
+    movement->goalX = 55.0F;
+    movement->goalY = 65.0F;
+    movement->vx = 1.5F;
+    movement->vz = 2.0F;
+    movement->pathPending = false;
+    movement->pendingRequestId = 42;
+    movement->repathCooldown = 1.0F;
+    movement->lastGoalX = 45.0F;
+    movement->lastGoalY = 55.0F;
+    movement->timeSinceLastPathRequest = 0.5F;
+    
+    movement->path.emplace_back(10.0F, 20.0F);
+    movement->path.emplace_back(30.0F, 40.0F);
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("movement"));
+    QJsonObject movement_obj = json["movement"].toObject();
+    
+    EXPECT_TRUE(movement_obj["hasTarget"].toBool());
+    EXPECT_FLOAT_EQ(movement_obj["target_x"].toDouble(), 50.0);
+    EXPECT_FLOAT_EQ(movement_obj["target_y"].toDouble(), 60.0);
+    EXPECT_FLOAT_EQ(movement_obj["goalX"].toDouble(), 55.0);
+    EXPECT_FLOAT_EQ(movement_obj["goalY"].toDouble(), 65.0);
+    EXPECT_FLOAT_EQ(movement_obj["vx"].toDouble(), 1.5);
+    EXPECT_FLOAT_EQ(movement_obj["vz"].toDouble(), 2.0);
+    EXPECT_FALSE(movement_obj["pathPending"].toBool());
+    EXPECT_EQ(movement_obj["pendingRequestId"].toVariant().toULongLong(), 42ULL);
+    
+    ASSERT_TRUE(movement_obj.contains("path"));
+    QJsonArray path_array = movement_obj["path"].toArray();
+    ASSERT_EQ(path_array.size(), 2);
+    
+    QJsonObject waypoint1 = path_array[0].toObject();
+    EXPECT_FLOAT_EQ(waypoint1["x"].toDouble(), 10.0);
+    EXPECT_FLOAT_EQ(waypoint1["y"].toDouble(), 20.0);
+    
+    QJsonObject waypoint2 = path_array[1].toObject();
+    EXPECT_FLOAT_EQ(waypoint2["x"].toDouble(), 30.0);
+    EXPECT_FLOAT_EQ(waypoint2["y"].toDouble(), 40.0);
+}
+
+TEST_F(SerializationTest, AttackComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* attack = entity->addComponent<AttackComponent>();
+    
+    attack->range = 10.0F;
+    attack->damage = 25;
+    attack->cooldown = 2.0F;
+    attack->timeSinceLast = 0.5F;
+    attack->meleeRange = 2.0F;
+    attack->meleeDamage = 15;
+    attack->meleeCooldown = 1.5F;
+    attack->preferredMode = AttackComponent::CombatMode::Ranged;
+    attack->currentMode = AttackComponent::CombatMode::Ranged;
+    attack->canMelee = true;
+    attack->canRanged = true;
+    attack->max_heightDifference = 5.0F;
+    attack->inMeleeLock = false;
+    attack->meleeLockTargetId = 0;
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("attack"));
+    QJsonObject attack_obj = json["attack"].toObject();
+    
+    EXPECT_FLOAT_EQ(attack_obj["range"].toDouble(), 10.0);
+    EXPECT_EQ(attack_obj["damage"].toInt(), 25);
+    EXPECT_FLOAT_EQ(attack_obj["cooldown"].toDouble(), 2.0);
+    EXPECT_FLOAT_EQ(attack_obj["timeSinceLast"].toDouble(), 0.5);
+    EXPECT_FLOAT_EQ(attack_obj["meleeRange"].toDouble(), 2.0);
+    EXPECT_EQ(attack_obj["meleeDamage"].toInt(), 15);
+    EXPECT_FLOAT_EQ(attack_obj["meleeCooldown"].toDouble(), 1.5);
+    EXPECT_EQ(attack_obj["preferredMode"].toString(), QString("ranged"));
+    EXPECT_EQ(attack_obj["currentMode"].toString(), QString("ranged"));
+    EXPECT_TRUE(attack_obj["canMelee"].toBool());
+    EXPECT_TRUE(attack_obj["canRanged"].toBool());
+    EXPECT_FLOAT_EQ(attack_obj["max_heightDifference"].toDouble(), 5.0);
+    EXPECT_FALSE(attack_obj["inMeleeLock"].toBool());
+}
+
+TEST_F(SerializationTest, EntityDeserializationRoundTrip) {
+    auto* original_entity = world->createEntity();
+    auto* transform = original_entity->addComponent<TransformComponent>();
+    transform->position.x = 100.0F;
+    transform->position.y = 200.0F;
+    transform->position.z = 300.0F;
+    
+    auto* unit = original_entity->addComponent<UnitComponent>();
+    unit->health = 75;
+    unit->max_health = 100;
+    unit->speed = 6.0F;
+    
+    QJsonObject json = Serialization::serializeEntity(original_entity);
+    
+    auto* new_entity = world->createEntity();
+    Serialization::deserializeEntity(new_entity, json);
+    
+    auto* deserialized_transform = new_entity->getComponent<TransformComponent>();
+    ASSERT_NE(deserialized_transform, nullptr);
+    EXPECT_FLOAT_EQ(deserialized_transform->position.x, 100.0F);
+    EXPECT_FLOAT_EQ(deserialized_transform->position.y, 200.0F);
+    EXPECT_FLOAT_EQ(deserialized_transform->position.z, 300.0F);
+    
+    auto* deserialized_unit = new_entity->getComponent<UnitComponent>();
+    ASSERT_NE(deserialized_unit, nullptr);
+    EXPECT_EQ(deserialized_unit->health, 75);
+    EXPECT_EQ(deserialized_unit->max_health, 100);
+    EXPECT_FLOAT_EQ(deserialized_unit->speed, 6.0F);
+}
+
+TEST_F(SerializationTest, DeserializationWithMissingFields) {
+    QJsonObject json;
+    json["id"] = 1;
+    
+    QJsonObject unit_obj;
+    unit_obj["health"] = 50;
+    json["unit"] = unit_obj;
+    
+    auto* entity = world->createEntity();
+    Serialization::deserializeEntity(entity, json);
+    
+    auto* unit = entity->getComponent<UnitComponent>();
+    ASSERT_NE(unit, nullptr);
+    EXPECT_EQ(unit->health, 50);
+    EXPECT_EQ(unit->max_health, Defaults::kUnitDefaultHealth);
+}
+
+TEST_F(SerializationTest, DeserializationWithMalformedJSON) {
+    QJsonObject json;
+    json["id"] = 1;
+    
+    QJsonObject transform_obj;
+    transform_obj["posX"] = "not_a_number";
+    json["transform"] = transform_obj;
+    
+    auto* entity = world->createEntity();
+    
+    EXPECT_NO_THROW({
+        Serialization::deserializeEntity(entity, json);
+    });
+    
+    auto* transform = entity->getComponent<TransformComponent>();
+    ASSERT_NE(transform, nullptr);
+    EXPECT_FLOAT_EQ(transform->position.x, 0.0F);
+}
+
+TEST_F(SerializationTest, WorldSerializationRoundTrip) {
+    auto* entity1 = world->createEntity();
+    auto* transform1 = entity1->addComponent<TransformComponent>();
+    transform1->position.x = 10.0F;
+    
+    auto* entity2 = world->createEntity();
+    auto* transform2 = entity2->addComponent<TransformComponent>();
+    transform2->position.x = 20.0F;
+    
+    QJsonDocument doc = Serialization::serializeWorld(world.get());
+    
+    ASSERT_TRUE(doc.isObject());
+    QJsonObject world_obj = doc.object();
+    EXPECT_TRUE(world_obj.contains("entities"));
+    EXPECT_TRUE(world_obj.contains("nextEntityId"));
+    EXPECT_TRUE(world_obj.contains("schemaVersion"));
+    
+    auto new_world = std::make_unique<World>();
+    Serialization::deserializeWorld(new_world.get(), doc);
+    
+    const auto& entities = new_world->getEntities();
+    EXPECT_EQ(entities.size(), 2UL);
+}
+
+TEST_F(SerializationTest, SaveAndLoadFromFile) {
+    auto* entity = world->createEntity();
+    auto* transform = entity->addComponent<TransformComponent>();
+    transform->position.x = 42.0F;
+    transform->position.y = 43.0F;
+    transform->position.z = 44.0F;
+    
+    QJsonDocument doc = Serialization::serializeWorld(world.get());
+    
+    QTemporaryFile temp_file;
+    ASSERT_TRUE(temp_file.open());
+    QString filename = temp_file.fileName();
+    temp_file.close();
+    
+    EXPECT_TRUE(Serialization::saveToFile(filename, doc));
+    
+    QJsonDocument loaded_doc = Serialization::loadFromFile(filename);
+    EXPECT_FALSE(loaded_doc.isNull());
+    
+    auto new_world = std::make_unique<World>();
+    Serialization::deserializeWorld(new_world.get(), loaded_doc);
+    
+    const auto& entities = new_world->getEntities();
+    EXPECT_EQ(entities.size(), 1UL);
+    
+    if (!entities.empty()) {
+        auto* loaded_entity = entities.begin()->second.get();
+        auto* loaded_transform = loaded_entity->getComponent<TransformComponent>();
+        ASSERT_NE(loaded_transform, nullptr);
+        EXPECT_FLOAT_EQ(loaded_transform->position.x, 42.0F);
+        EXPECT_FLOAT_EQ(loaded_transform->position.y, 43.0F);
+        EXPECT_FLOAT_EQ(loaded_transform->position.z, 44.0F);
+    }
+}
+
+TEST_F(SerializationTest, ProductionComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* production = entity->addComponent<ProductionComponent>();
+    
+    production->inProgress = true;
+    production->buildTime = 10.0F;
+    production->timeRemaining = 5.0F;
+    production->producedCount = 3;
+    production->maxUnits = 10;
+    production->product_type = Game::Units::TroopType::Archer;
+    production->rallyX = 100.0F;
+    production->rallyZ = 200.0F;
+    production->rallySet = true;
+    production->villagerCost = 2;
+    production->productionQueue.push_back(Game::Units::TroopType::Spearman);
+    production->productionQueue.push_back(Game::Units::TroopType::Archer);
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("production"));
+    QJsonObject prod_obj = json["production"].toObject();
+    
+    EXPECT_TRUE(prod_obj["inProgress"].toBool());
+    EXPECT_FLOAT_EQ(prod_obj["buildTime"].toDouble(), 10.0);
+    EXPECT_FLOAT_EQ(prod_obj["timeRemaining"].toDouble(), 5.0);
+    EXPECT_EQ(prod_obj["producedCount"].toInt(), 3);
+    EXPECT_EQ(prod_obj["maxUnits"].toInt(), 10);
+    EXPECT_EQ(prod_obj["product_type"].toString(), QString("archer"));
+    EXPECT_FLOAT_EQ(prod_obj["rallyX"].toDouble(), 100.0);
+    EXPECT_FLOAT_EQ(prod_obj["rallyZ"].toDouble(), 200.0);
+    EXPECT_TRUE(prod_obj["rallySet"].toBool());
+    EXPECT_EQ(prod_obj["villagerCost"].toInt(), 2);
+    
+    ASSERT_TRUE(prod_obj.contains("queue"));
+    QJsonArray queue = prod_obj["queue"].toArray();
+    EXPECT_EQ(queue.size(), 2);
+    EXPECT_EQ(queue[0].toString(), QString("spearman"));
+    EXPECT_EQ(queue[1].toString(), QString("archer"));
+}
+
+TEST_F(SerializationTest, PatrolComponentSerialization) {
+    auto* entity = world->createEntity();
+    auto* patrol = entity->addComponent<PatrolComponent>();
+    
+    patrol->currentWaypoint = 1;
+    patrol->patrolling = true;
+    patrol->waypoints.emplace_back(10.0F, 20.0F);
+    patrol->waypoints.emplace_back(30.0F, 40.0F);
+    patrol->waypoints.emplace_back(50.0F, 60.0F);
+    
+    QJsonObject json = Serialization::serializeEntity(entity);
+    
+    ASSERT_TRUE(json.contains("patrol"));
+    QJsonObject patrol_obj = json["patrol"].toObject();
+    
+    EXPECT_EQ(patrol_obj["currentWaypoint"].toInt(), 1);
+    EXPECT_TRUE(patrol_obj["patrolling"].toBool());
+    
+    ASSERT_TRUE(patrol_obj.contains("waypoints"));
+    QJsonArray waypoints = patrol_obj["waypoints"].toArray();
+    EXPECT_EQ(waypoints.size(), 3);
+    
+    QJsonObject wp0 = waypoints[0].toObject();
+    EXPECT_FLOAT_EQ(wp0["x"].toDouble(), 10.0);
+    EXPECT_FLOAT_EQ(wp0["y"].toDouble(), 20.0);
+}
+
+TEST_F(SerializationTest, EmptyWorldSerialization) {
+    QJsonDocument doc = Serialization::serializeWorld(world.get());
+    
+    ASSERT_TRUE(doc.isObject());
+    QJsonObject world_obj = doc.object();
+    
+    EXPECT_TRUE(world_obj.contains("entities"));
+    QJsonArray entities = world_obj["entities"].toArray();
+    EXPECT_EQ(entities.size(), 0);
+}

tests/db/save_storage_test.cpp

@@ -0,0 +1,376 @@
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QString>
+#include "systems/save_storage.h"
+
+using namespace Game::Systems;
+
+class SaveStorageTest : public ::testing::Test {
+protected:
+    void SetUp() override {
+        storage = std::make_unique<SaveStorage>(":memory:");
+        QString error;
+        bool initialized = storage->initialize(&error);
+        ASSERT_TRUE(initialized) << "Failed to initialize: " << error.toStdString();
+    }
+
+    void TearDown() override {
+        storage.reset();
+    }
+
+    std::unique_ptr<SaveStorage> storage;
+};
+
+TEST_F(SaveStorageTest, InitializationSuccess) {
+    EXPECT_NE(storage, nullptr);
+}
+
+TEST_F(SaveStorageTest, SaveSlotBasic) {
+    QString slot_name = "test_slot";
+    QString title = "Test Save Game";
+    
+    QJsonObject metadata;
+    metadata["level"] = 5;
+    metadata["score"] = 1000;
+    
+    QByteArray world_state("world_state_data");
+    QByteArray screenshot("screenshot_data");
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, title, metadata, world_state, screenshot, &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
+}
+
+TEST_F(SaveStorageTest, SaveAndLoadSlot) {
+    QString slot_name = "save_load_test";
+    QString original_title = "Original Title";
+    
+    QJsonObject original_metadata;
+    original_metadata["player_name"] = "TestPlayer";
+    original_metadata["game_time"] = 3600;
+    original_metadata["difficulty"] = "hard";
+    
+    QByteArray original_world_state("test_world_state_content");
+    QByteArray original_screenshot("test_screenshot_content");
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, original_title, original_metadata, 
+                                    original_world_state, original_screenshot, &error);
+    ASSERT_TRUE(saved) << "Save failed: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    ASSERT_TRUE(loaded) << "Load failed: " << error.toStdString();
+    
+    EXPECT_EQ(loaded_title, original_title);
+    EXPECT_EQ(loaded_world_state, original_world_state);
+    EXPECT_EQ(loaded_screenshot, original_screenshot);
+    
+    EXPECT_EQ(loaded_metadata["player_name"].toString(), QString("TestPlayer"));
+    EXPECT_EQ(loaded_metadata["game_time"].toInt(), 3600);
+    EXPECT_EQ(loaded_metadata["difficulty"].toString(), QString("hard"));
+}
+
+TEST_F(SaveStorageTest, OverwriteExistingSlot) {
+    QString slot_name = "overwrite_test";
+    QString title1 = "First Save";
+    QString title2 = "Second Save";
+    
+    QJsonObject metadata1;
+    metadata1["version"] = 1;
+    
+    QJsonObject metadata2;
+    metadata2["version"] = 2;
+    
+    QByteArray world_state1("state1");
+    QByteArray world_state2("state2");
+    
+    QString error;
+    
+    bool saved1 = storage->saveSlot(slot_name, title1, metadata1, world_state1, 
+                                     QByteArray(), &error);
+    ASSERT_TRUE(saved1) << "First save failed: " << error.toStdString();
+    
+    bool saved2 = storage->saveSlot(slot_name, title2, metadata2, world_state2,
+                                     QByteArray(), &error);
+    ASSERT_TRUE(saved2) << "Second save failed: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    ASSERT_TRUE(loaded) << "Load failed: " << error.toStdString();
+    
+    EXPECT_EQ(loaded_title, title2);
+    EXPECT_EQ(loaded_world_state, world_state2);
+    EXPECT_EQ(loaded_metadata["version"].toInt(), 2);
+}
+
+TEST_F(SaveStorageTest, LoadNonExistentSlot) {
+    QString slot_name = "nonexistent_slot";
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    QString error;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_FALSE(loaded);
+    EXPECT_FALSE(error.isEmpty());
+}
+
+TEST_F(SaveStorageTest, ListSlots) {
+    QString error;
+    
+    QByteArray non_empty_data("test_data");
+    storage->saveSlot("slot1", "Title 1", QJsonObject(), non_empty_data, QByteArray(), &error);
+    storage->saveSlot("slot2", "Title 2", QJsonObject(), non_empty_data, QByteArray(), &error);
+    storage->saveSlot("slot3", "Title 3", QJsonObject(), non_empty_data, QByteArray(), &error);
+    
+    QVariantList slot_list = storage->listSlots(&error);
+    
+    EXPECT_TRUE(error.isEmpty()) << "List failed: " << error.toStdString();
+    EXPECT_EQ(slot_list.size(), 3);
+    
+    bool found_slot1 = false;
+    bool found_slot2 = false;
+    bool found_slot3 = false;
+    
+    for (const QVariant& slot_variant : slot_list) {
+        QVariantMap slot = slot_variant.toMap();
+        QString slot_name = slot["slotName"].toString();
+        
+        if (slot_name == "slot1") {
+            found_slot1 = true;
+            EXPECT_EQ(slot["title"].toString(), QString("Title 1"));
+        } else if (slot_name == "slot2") {
+            found_slot2 = true;
+            EXPECT_EQ(slot["title"].toString(), QString("Title 2"));
+        } else if (slot_name == "slot3") {
+            found_slot3 = true;
+            EXPECT_EQ(slot["title"].toString(), QString("Title 3"));
+        }
+    }
+    
+    EXPECT_TRUE(found_slot1);
+    EXPECT_TRUE(found_slot2);
+    EXPECT_TRUE(found_slot3);
+}
+
+TEST_F(SaveStorageTest, DeleteSlot) {
+    QString slot_name = "delete_test";
+    QString error;
+    
+    QByteArray non_empty_data("test_data");
+    storage->saveSlot(slot_name, "Title", QJsonObject(), non_empty_data, QByteArray(), &error);
+    
+    QVariantList slots_before = storage->listSlots(&error);
+    EXPECT_EQ(slots_before.size(), 1);
+    
+    bool deleted = storage->deleteSlot(slot_name, &error);
+    EXPECT_TRUE(deleted) << "Delete failed: " << error.toStdString();
+    
+    QVariantList slots_after = storage->listSlots(&error);
+    EXPECT_EQ(slots_after.size(), 0);
+}
+
+TEST_F(SaveStorageTest, DeleteNonExistentSlot) {
+    QString slot_name = "nonexistent_delete";
+    QString error;
+    
+    bool deleted = storage->deleteSlot(slot_name, &error);
+    
+    EXPECT_FALSE(deleted);
+    EXPECT_FALSE(error.isEmpty());
+}
+
+TEST_F(SaveStorageTest, EmptyMetadataSave) {
+    QString slot_name = "empty_metadata";
+    QJsonObject empty_metadata;
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, "Title", empty_metadata, 
+                                    QByteArray("data"), QByteArray(), &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
+}
+
+TEST_F(SaveStorageTest, EmptyWorldStateSave) {
+    QString slot_name = "empty_world_state";
+    QByteArray minimal_world_state(" ");
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, "Title", QJsonObject(), 
+                                    minimal_world_state, QByteArray(), &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
+    EXPECT_EQ(loaded_world_state, minimal_world_state);
+}
+
+TEST_F(SaveStorageTest, LargeDataSave) {
+    QString slot_name = "large_data";
+    
+    QByteArray large_world_state(1024 * 1024, 'A');
+    QByteArray large_screenshot(512 * 1024, 'B');
+    
+    QJsonObject metadata;
+    metadata["size"] = "large";
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, "Large Data Test", metadata, 
+                                    large_world_state, large_screenshot, &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save large data: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_TRUE(loaded) << "Failed to load large data: " << error.toStdString();
+    EXPECT_EQ(loaded_world_state.size(), 1024 * 1024);
+    EXPECT_EQ(loaded_screenshot.size(), 512 * 1024);
+}
+
+TEST_F(SaveStorageTest, SpecialCharactersInSlotName) {
+    QString slot_name = "slot_with_special_chars_123";
+    QString title = "Title with special chars: !@#$%^&*()";
+    
+    QJsonObject metadata;
+    metadata["description"] = "Test with special characters: <>&\"'";
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, title, metadata, 
+                                    QByteArray("data"), QByteArray(), &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
+    EXPECT_EQ(loaded_title, title);
+}
+
+TEST_F(SaveStorageTest, ComplexMetadataSave) {
+    QString slot_name = "complex_metadata";
+    
+    QJsonObject metadata;
+    metadata["int_value"] = 42;
+    metadata["double_value"] = 3.14159;
+    metadata["string_value"] = "test_string";
+    metadata["bool_value"] = true;
+    
+    QJsonObject nested_object;
+    nested_object["nested_field"] = "nested_value";
+    metadata["nested"] = nested_object;
+    
+    QJsonArray array;
+    array.append(1);
+    array.append(2);
+    array.append(3);
+    metadata["array"] = array;
+    
+    QString error;
+    bool saved = storage->saveSlot(slot_name, "Complex Metadata Test", metadata,
+                                    QByteArray("data"), QByteArray(), &error);
+    
+    EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
+    
+    QByteArray loaded_world_state;
+    QJsonObject loaded_metadata;
+    QByteArray loaded_screenshot;
+    QString loaded_title;
+    
+    bool loaded = storage->loadSlot(slot_name, loaded_world_state, loaded_metadata,
+                                     loaded_screenshot, loaded_title, &error);
+    
+    EXPECT_TRUE(loaded) << "Failed to load: " << error.toStdString();
+    
+    EXPECT_EQ(loaded_metadata["int_value"].toInt(), 42);
+    EXPECT_DOUBLE_EQ(loaded_metadata["double_value"].toDouble(), 3.14159);
+    EXPECT_EQ(loaded_metadata["string_value"].toString(), QString("test_string"));
+    EXPECT_TRUE(loaded_metadata["bool_value"].toBool());
+    
+    QJsonObject loaded_nested = loaded_metadata["nested"].toObject();
+    EXPECT_EQ(loaded_nested["nested_field"].toString(), QString("nested_value"));
+    
+    QJsonArray loaded_array = loaded_metadata["array"].toArray();
+    EXPECT_EQ(loaded_array.size(), 3);
+    EXPECT_EQ(loaded_array[0].toInt(), 1);
+    EXPECT_EQ(loaded_array[1].toInt(), 2);
+    EXPECT_EQ(loaded_array[2].toInt(), 3);
+}
+
+TEST_F(SaveStorageTest, MultipleSavesAndDeletes) {
+    QString error;
+    
+    for (int i = 0; i < 10; i++) {
+        QString slot_name = QString("slot_%1").arg(i);
+        storage->saveSlot(slot_name, QString("Title %1").arg(i), 
+                         QJsonObject(), QByteArray("data"), QByteArray(), &error);
+    }
+    
+    QVariantList slot_list = storage->listSlots(&error);
+    EXPECT_EQ(slot_list.size(), 10);
+    
+    for (int i = 0; i < 5; i++) {
+        QString slot_name = QString("slot_%1").arg(i);
+        storage->deleteSlot(slot_name, &error);
+    }
+    
+    slot_list = storage->listSlots(&error);
+    EXPECT_EQ(slot_list.size(), 5);
+    
+    for (const QVariant& slot_variant : slot_list) {
+        QVariantMap slot = slot_variant.toMap();
+        QString slot_name = slot["slotName"].toString();
+        int slot_num = slot_name.mid(5).toInt();
+        EXPECT_GE(slot_num, 5);
+        EXPECT_LT(slot_num, 10);
+    }
+}