Fluorine Manager: full Linux port of Mod Organizer 2

Complete native Linux port with FUSE-based virtual filesystem,
Proton/umu-run integration, and Flatpak packaging.

Key features:
- FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak)
- Proton/GE-Proton/umu-run launcher with env var forwarding
- Flatpak support (sandbox-aware VFS, NXM handler, umu-run)
- Wine prefix management UI
- Case-insensitive path resolution for Linux filesystems
- QSettings-safe INI handling (avoids Bethesda INI corruption)
- Portable instance support with auto-generated launcher scripts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

35 files changed, 1410 insertions, 0 deletions

diff --git a/libs/bsapacker/tests/ArchiveAutoServiceFacts.cpp b/libs/bsapacker/tests/ArchiveAutoServiceFacts.cpp
new file mode 100644
index 0000000..8fd37f1
--- /dev/null
+++ b/libs/bsapacker/tests/ArchiveAutoServiceFacts.cpp
@@ -0,0 +1,26 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/ArchiveAutoService.h>
+
+using namespace BsaPacker;
+
+namespace BsaPackerTests
+{
+	class ArchiveAutoServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+		}
+
+		void TearDown() override {
+		}
+	};
+
+	TEST_F(ArchiveAutoServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = ArchiveAutoService();
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/ArchiveBuilderFactoryFacts.cpp b/libs/bsapacker/tests/ArchiveBuilderFactoryFacts.cpp
new file mode 100644
index 0000000..352fc00
--- /dev/null
+++ b/libs/bsapacker/tests/ArchiveBuilderFactoryFacts.cpp
@@ -0,0 +1,242 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/ArchiveBuilderFactory.h>
+#include "MockArchiveBuilderHelper.h"
+#include "ModDto.h"
+#include "NexusId.h"
+#include <bsapacker/NullArchiveBuilder.h>
+#include <bsapacker/GeneralArchiveBuilder.h>
+#include <bsapacker/TexturelessArchiveBuilder.h>
+#include <bsapacker/TextureArchiveBuilder.h>
+#include <typeindex>
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class ArchiveBuilderFactoryFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockArchiveBuilderHelper = new NaggyMock<MockArchiveBuilderHelper>();
+		}
+
+		void TearDown() override {
+			delete naggyMockArchiveBuilderHelper;
+		}
+
+		NaggyMock<MockArchiveBuilderHelper>* naggyMockArchiveBuilderHelper;
+	};
+
+	TEST_F(ArchiveBuilderFactoryFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		);
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsMorrowind_ReturnsbaTES3)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::Morrowind, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baTES3, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsOblivion_ReturnsbaTES4)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::Oblivion, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baTES4, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsFallout3_ReturnsbaFO3)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::Fallout3, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baFO3, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsNewVegas_ReturnsbaFO3)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::NewVegas, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baFO3, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsSkyrim_ReturnsbaFO3)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::Skyrim, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baFO3, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsSkyrimSE_ReturnsbaSSE)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::SkyrimSE, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baSSE, result.at(0));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, GetArchiveTypes_WhenNexusIdIsFallout4_ReturnsbaFO4andbaFO4dds)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto dto = ModDto(NexusId::Fallout4, "", "", "");
+
+		// Act
+		auto result = sut.GetArchiveTypes(&dto);
+
+		// Assert
+		EXPECT_EQ(bsa_archive_type_e::baFO4, result.at(0));
+		EXPECT_EQ(bsa_archive_type_e::baFO4dds, result.at(1));
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeNone_ReturnsNullArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baNone;
+
+		// Act
+		auto returned = sut.Create(type, nullptr);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<NullArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(NullArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeTES3_ReturnsGeneralArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baTES3;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<GeneralArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(GeneralArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeTES4_ReturnsGeneralArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baTES4;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<GeneralArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(GeneralArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeFO3_ReturnsGeneralArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baFO3;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<GeneralArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(GeneralArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeSSE_ReturnsGeneralArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baSSE;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<GeneralArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(GeneralArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeFO4_ReturnsTexturelessArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baFO4;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<TexturelessArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(TexturelessArchiveBuilder).name(), typeid(*resultType).name());
+	}
+
+	TEST_F(ArchiveBuilderFactoryFacts, Create_WhenArchiveTypeFO4dds_ReturnsTextureArchiveBuilder)
+	{
+		// Arrange
+		auto sut = ArchiveBuilderFactory(naggyMockArchiveBuilderHelper);
+		auto type = bsa_archive_type_e::baFO4dds;
+		auto dto = ModDto(0, "", "", "");
+
+		// Act
+		auto returned = sut.Create(type, &dto);
+		auto result = returned.get();
+
+		// Assert
+		auto resultType = dynamic_cast<TextureArchiveBuilder*>(result);
+		EXPECT_STREQ(typeid(TextureArchiveBuilder).name(), typeid(*resultType).name());
+	}
+}
diff --git a/libs/bsapacker/tests/ArchiveBuilderHelperFacts.cpp b/libs/bsapacker/tests/ArchiveBuilderHelperFacts.cpp
new file mode 100644
index 0000000..a970c24
--- /dev/null
+++ b/libs/bsapacker/tests/ArchiveBuilderHelperFacts.cpp
@@ -0,0 +1,37 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/ArchiveBuilderHelper.h>
+#include "MockSettingsService.h"
+
+using namespace BsaPacker;
+using std::filesystem::path;
+using ::testing::NaggyMock;
+using ::testing::Return;
+
+namespace BsaPackerTests
+{
+	class ArchiveBuilderHelperFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockSettingsService = new NaggyMock<MockSettingsService>();
+			naggyPath = new NaggyMock<path>();
+		}
+
+		void TearDown() override {
+			delete naggyMockSettingsService;
+			delete naggyPath;
+		}
+
+		NaggyMock<MockSettingsService>* naggyMockSettingsService;
+		NaggyMock<std::filesystem::path>* naggyPath;
+	};
+
+	TEST_F(ArchiveBuilderHelperFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = ArchiveBuilderHelper(naggyMockSettingsService);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/ArchiveNameServiceFacts.cpp b/libs/bsapacker/tests/ArchiveNameServiceFacts.cpp
new file mode 100644
index 0000000..c79c545
--- /dev/null
+++ b/libs/bsapacker/tests/ArchiveNameServiceFacts.cpp
@@ -0,0 +1,260 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "ArchiveNameService.h"
+#include "MockModContext.h"
+#include "ModDto.h"
+#include "NexusId.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+using ::testing::Eq;
+using ::testing::Return;
+
+namespace BsaPackerTests
+{
+	class ArchiveNameServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockModContext = new NaggyMock<MockModContext>();
+		}
+
+		void TearDown() override {
+			delete naggyMockModContext;
+		}
+
+		NaggyMock<MockModContext>* naggyMockModContext;
+	};
+
+	TEST_F(ArchiveNameServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = ArchiveNameService(
+				naggyMockModContext
+			);
+		);
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsMorrowind_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Morrowind));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsOblivion_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Oblivion));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsFallout3_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Fallout3));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsNewVegas_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::NewVegas));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsSkyrim_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Skyrim));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsSkyrimSE_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::SkyrimSE));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_WhenNexusIdIsFallout4_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Fallout4));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ(".ba2", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetFileExtension_InvalidNexusId_Returnsbsa)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(0));
+
+		// Act
+		auto result = sut.GetFileExtension();
+
+		// Assert
+		EXPECT_EQ("", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaFO4_ReturnsFullPathWithMainInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baFO4;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Fallout4));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive - Main.ba2", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaFO4dds_ReturnsFullPathWithTextureInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baFO4dds;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Fallout4));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive - Textures.ba2", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaTES3_ReturnsFullPathWithoutInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baTES3;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Morrowind));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive.bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaTES4_ReturnsFullPathWithoutInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baTES3;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Oblivion));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive.bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaFO3_ReturnsFullPathWithoutInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baFO3;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::Fallout3));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive.bsa", result.toStdString());
+	}
+
+	TEST_F(ArchiveNameServiceFacts, GetArchiveFullPath_WhenTypeIsbaSSE_ReturnsFullPathWithoutInfix)
+	{
+		// Arrange
+		auto sut = ArchiveNameService(
+				naggyMockModContext);
+		auto type = bsa_archive_type_e::baSSE;
+		auto dto = ModDto(0, "C:/directory", "archive", ".ba2");
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(NexusId::SkyrimSE));
+
+		// Act
+		auto result = sut.GetArchiveFullPath(type, &dto);
+
+		// Assert
+		EXPECT_EQ("C:/directory/archive.bsa", result.toStdString());
+	}
+}
diff --git a/libs/bsapacker/tests/BsaPackerFacts.cpp b/libs/bsapacker/tests/BsaPackerFacts.cpp
new file mode 100644
index 0000000..d3e8e59
--- /dev/null
+++ b/libs/bsapacker/tests/BsaPackerFacts.cpp
@@ -0,0 +1,34 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "BsaPacker.h"
+#include "MockOrganizer.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+using ::testing::Return;
+using ::testing::Eq;
+
+namespace BsaPackerTests
+{
+	class BsaPackerFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockOrganizer = new NaggyMock<MockOrganizer>();
+		}
+
+		void TearDown() override {
+			delete naggyMockOrganizer;
+		}
+
+		NaggyMock<MockOrganizer>* naggyMockOrganizer;
+	};
+
+	TEST_F(BsaPackerFacts, CtorAndInit_Always_Constructs)
+	{
+		auto result = Bsa_Packer();
+		EXPECT_NO_THROW(result.init(naggyMockOrganizer));
+	}
+
+}
diff --git a/libs/bsapacker/tests/BsaPackerWorkerFacts.cpp b/libs/bsapacker/tests/BsaPackerWorkerFacts.cpp
new file mode 100644
index 0000000..851ae3c
--- /dev/null
+++ b/libs/bsapacker/tests/BsaPackerWorkerFacts.cpp
@@ -0,0 +1,67 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "BsaPackerWorker.h"
+#include "MockSettingsService.h"
+#include "MockModDtoFactory.h"
+#include "MockArchiveBuilderFactory.h"
+#include "MockDummyPluginServiceFactory.h"
+#include "MockArchiveAutoService.h"
+#include "MockHideLooseAssetService.h"
+#include "MockArchiveNameService.h"
+#include "MockOverrideFileService.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class BsaPackerWorkerFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override
+		{
+			naggyMockSettingsService = new NaggyMock<MockSettingsService>();
+			naggyMockModDtoFactory = new NaggyMock<MockModDtoFactory>();
+			naggyMockArchiveBuilderFactory = new NaggyMock<MockArchiveBuilderFactory>();
+			naggyMockArchiveAutoService = new NaggyMock<MockArchiveAutoService>();
+			naggyMockDummyPluginServiceFactory = new NaggyMock<MockDummyPluginServiceFactory>();
+			naggyMockHideLooseAssetService = new NaggyMock<MockHideLooseAssetService>();
+			naggyMockArchiveNameService = new NaggyMock<MockArchiveNameService>();
+			naggyOverrideFileService = new NaggyMock<MockOverrideFileService>();
+		}
+
+		void TearDown() override
+		{
+			delete naggyMockSettingsService;
+			delete naggyMockModDtoFactory;
+			delete naggyMockArchiveBuilderFactory;
+			delete naggyMockArchiveAutoService;
+			delete naggyMockDummyPluginServiceFactory;
+			delete naggyMockHideLooseAssetService;
+			delete naggyMockArchiveNameService;
+		}
+
+		NaggyMock<MockSettingsService> *naggyMockSettingsService;
+		NaggyMock<MockModDtoFactory> *naggyMockModDtoFactory;
+		NaggyMock<MockArchiveBuilderFactory> *naggyMockArchiveBuilderFactory;
+		NaggyMock<MockArchiveAutoService> *naggyMockArchiveAutoService;
+		NaggyMock<MockDummyPluginServiceFactory> *naggyMockDummyPluginServiceFactory;
+		NaggyMock<MockHideLooseAssetService> *naggyMockHideLooseAssetService;
+		NaggyMock<MockArchiveNameService> *naggyMockArchiveNameService;
+		NaggyMock<MockOverrideFileService> *naggyOverrideFileService;
+	};
+
+	TEST_F(BsaPackerWorkerFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(BsaPackerWorker(
+			naggyMockSettingsService,
+			naggyMockModDtoFactory,
+			naggyMockArchiveBuilderFactory,
+			naggyMockArchiveAutoService,
+			naggyMockDummyPluginServiceFactory,
+			naggyMockHideLooseAssetService,
+			naggyMockArchiveNameService,
+			naggyOverrideFileService));
+	}
+}
diff --git a/libs/bsapacker/tests/CMakeLists.txt b/libs/bsapacker/tests/CMakeLists.txt
new file mode 100644
index 0000000..5f482a7
--- /dev/null
+++ b/libs/bsapacker/tests/CMakeLists.txt
@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.22)
+
+add_executable(bsa_packer_tests)
+mo2_configure_tests(bsa_packer_tests WARNINGS OFF)
+target_link_libraries(bsa_packer_tests PRIVATE bsa_packer)
diff --git a/libs/bsapacker/tests/DummyPluginServiceFactoryFacts.cpp b/libs/bsapacker/tests/DummyPluginServiceFactoryFacts.cpp
new file mode 100644
index 0000000..c662438
--- /dev/null
+++ b/libs/bsapacker/tests/DummyPluginServiceFactoryFacts.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "DummyPluginServiceFactory.h"
+#include "MockModContext.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class DummyPluginServiceFactoryFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockModContext = new NaggyMock<MockModContext>();
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockModContext;
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockModContext>* naggyMockModContext;
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(DummyPluginServiceFactoryFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = DummyPluginServiceFactory(
+				naggyMockModContext,
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/Fallout3DummyPluginServiceFacts.cpp b/libs/bsapacker/tests/Fallout3DummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..e485d56
--- /dev/null
+++ b/libs/bsapacker/tests/Fallout3DummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "Fallout3DummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class Fallout3DummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(Fallout3DummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = Fallout3DummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/Fallout4DummyPluginServiceFacts.cpp b/libs/bsapacker/tests/Fallout4DummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..07d7139
--- /dev/null
+++ b/libs/bsapacker/tests/Fallout4DummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "Fallout4DummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class Fallout4DummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(Fallout4DummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = Fallout4DummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/FileWriterServiceFacts.cpp b/libs/bsapacker/tests/FileWriterServiceFacts.cpp
new file mode 100644
index 0000000..5038640
--- /dev/null
+++ b/libs/bsapacker/tests/FileWriterServiceFacts.cpp
@@ -0,0 +1,26 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "FileWriterService.h"
+
+using namespace BsaPacker;
+
+namespace BsaPackerTests
+{
+	class FileWriterServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+		}
+
+		void TearDown() override {
+		}
+	};
+
+	TEST_F(FileWriterServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = FileWriterService();
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/GeneralArchiveBuilderFacts.cpp b/libs/bsapacker/tests/GeneralArchiveBuilderFacts.cpp
new file mode 100644
index 0000000..2139a44
--- /dev/null
+++ b/libs/bsapacker/tests/GeneralArchiveBuilderFacts.cpp
@@ -0,0 +1,35 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/GeneralArchiveBuilder.h>
+#include "MockArchiveBuilderHelper.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class GeneralArchiveBuilderFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockArchiveBuilderHelper = new NaggyMock<MockArchiveBuilderHelper>();
+		}
+
+		void TearDown() override {
+			delete naggyMockArchiveBuilderHelper;
+		}
+
+		NaggyMock<MockArchiveBuilderHelper>* naggyMockArchiveBuilderHelper;
+	};
+
+	TEST_F(GeneralArchiveBuilderFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = GeneralArchiveBuilder(
+				naggyMockArchiveBuilderHelper,
+				QDir(),
+				baNone);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/HideLooseAssetServiceFacts.cpp b/libs/bsapacker/tests/HideLooseAssetServiceFacts.cpp
new file mode 100644
index 0000000..c868b8d
--- /dev/null
+++ b/libs/bsapacker/tests/HideLooseAssetServiceFacts.cpp
@@ -0,0 +1,33 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "HideLooseAssetService.h"
+#include "MockSettingsService.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class HideLooseAssetServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockSettingsService = new NaggyMock<MockSettingsService>();
+		}
+
+		void TearDown() override {
+			delete naggyMockSettingsService;
+		}
+
+		NaggyMock<MockSettingsService>* naggyMockSettingsService;
+	};
+
+	TEST_F(HideLooseAssetServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = HideLooseAssetService(
+				naggyMockSettingsService);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/MockArchiveAutoService.h b/libs/bsapacker/tests/MockArchiveAutoService.h
new file mode 100644
index 0000000..ebbbcfa
--- /dev/null
+++ b/libs/bsapacker/tests/MockArchiveAutoService.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IArchiveAutoService.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockArchiveAutoService : public IArchiveAutoService
+{
+public:
+	MOCK_METHOD(bool, CreateBSA, (libbsarch::bs_archive_auto *, const QString &, bsa_archive_type_e), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockArchiveBuilderFactory.h b/libs/bsapacker/tests/MockArchiveBuilderFactory.h
new file mode 100644
index 0000000..61a7ce4
--- /dev/null
+++ b/libs/bsapacker/tests/MockArchiveBuilderFactory.h
@@ -0,0 +1,11 @@
+#include <bsapacker/IArchiveBuilderFactory.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockArchiveBuilderFactory : public IArchiveBuilderFactory
+{
+public:
+	MOCK_METHOD(std::vector<bsa_archive_type_e>, GetArchiveTypes, (const IModDto*), (const, override));
+	MOCK_METHOD(std::unique_ptr<IArchiveBuilder>, Create, (bsa_archive_type_e, const IModDto*), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockArchiveBuilderHelper.h b/libs/bsapacker/tests/MockArchiveBuilderHelper.h
new file mode 100644
index 0000000..632977e
--- /dev/null
+++ b/libs/bsapacker/tests/MockArchiveBuilderHelper.h
@@ -0,0 +1,15 @@
+#include <bsapacker/IArchiveBuilderHelper.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockArchiveBuilderHelper : public IArchiveBuilderHelper
+{
+public:
+	MOCK_METHOD(bool, isFileIgnorable, (const std::filesystem::path&, const std::vector<std::filesystem::path::string_type>&), (const, override));
+	MOCK_METHOD(bool, isIncompressible, (const std::filesystem::path&), (const, override));
+	MOCK_METHOD(bool, isExtensionBlacklisted, (const std::filesystem::path&), (const, override));
+	MOCK_METHOD(uint32_t, getFileCount, (const std::filesystem::path&), (const, override));
+	MOCK_METHOD(std::vector<std::filesystem::path::string_type>, getRootDirectoryFilenames, (const std::filesystem::path&), (const, override));
+	MOCK_METHOD(bool, doesPathContainFiles, (const std::filesystem::path&, const std::vector<std::filesystem::path::string_type>&), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockArchiveNameService.h b/libs/bsapacker/tests/MockArchiveNameService.h
new file mode 100644
index 0000000..94dd68b
--- /dev/null
+++ b/libs/bsapacker/tests/MockArchiveNameService.h
@@ -0,0 +1,13 @@
+#include <bsapacker/IArchiveNameService.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockArchiveNameService : public IArchiveNameService
+{
+public:
+	MOCK_METHOD(QString, GetFileExtension, (), (const, override));
+	MOCK_METHOD(QString, GetArchiveFullPath, (bsa_archive_type_e, const IModDto *), (const, override));
+	MOCK_METHOD(QString, Infix, (bsa_archive_type_e type), (const, override));
+	MOCK_METHOD(QString, Suffix, (const QString &pathNoExt), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockDummyPluginLogic.h b/libs/bsapacker/tests/MockDummyPluginLogic.h
new file mode 100644
index 0000000..5bdaa50
--- /dev/null
+++ b/libs/bsapacker/tests/MockDummyPluginLogic.h
@@ -0,0 +1,11 @@
+#include <bsapacker/IDummyPluginLogic.h>
+#include "gmock/gmock.h"
+
+using namespace BsaPacker;
+
+class MockDummyPluginLogic : public IDummyPluginLogic
+{
+public:
+	MOCK_METHOD(bool, canCreateDummyESP, (const QString &, const bsa_archive_type_e), (const, override));
+	MOCK_METHOD(bool, canCreateDummyESL, (const QString &, const bsa_archive_type_e), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockDummyPluginServiceFactory.h b/libs/bsapacker/tests/MockDummyPluginServiceFactory.h
new file mode 100644
index 0000000..36ccc29
--- /dev/null
+++ b/libs/bsapacker/tests/MockDummyPluginServiceFactory.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IDummyPluginServiceFactory.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockDummyPluginServiceFactory : public IDummyPluginServiceFactory
+{
+public:
+	MOCK_METHOD(std::unique_ptr<IDummyPluginService>, Create, (), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockFileWriterService.h b/libs/bsapacker/tests/MockFileWriterService.h
new file mode 100644
index 0000000..164ba5a
--- /dev/null
+++ b/libs/bsapacker/tests/MockFileWriterService.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IFileWriterService.h>
+#include "gmock/gmock.h"
+
+using namespace BsaPacker;
+
+class MockFileWriterService : public IFileWriterService
+{
+public:
+	MOCK_METHOD(bool, Write, (const std::string&, const char*, uint32_t), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockHideLooseAssetService.h b/libs/bsapacker/tests/MockHideLooseAssetService.h
new file mode 100644
index 0000000..681534d
--- /dev/null
+++ b/libs/bsapacker/tests/MockHideLooseAssetService.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IHideLooseAssetService.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockHideLooseAssetService : public IHideLooseAssetService
+{
+public:
+	MOCK_METHOD(bool, HideLooseAssets, (const QDir&), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockModContext.h b/libs/bsapacker/tests/MockModContext.h
new file mode 100644
index 0000000..fedb3ff
--- /dev/null
+++ b/libs/bsapacker/tests/MockModContext.h
@@ -0,0 +1,13 @@
+#include <bsapacker/IModContext.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockModContext : public IModContext
+{
+public:
+	MOCK_METHOD(QString, GetAbsoluteModPath, (const QString& modName), (const, override));
+	MOCK_METHOD(int, GetNexusId, (), (const, override));
+	MOCK_METHOD(QStringList, GetPlugins, (const QDir& modDirectory), (const, override));
+	MOCK_METHOD(QStringList, GetValidMods, (), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockModDtoFactory.h b/libs/bsapacker/tests/MockModDtoFactory.h
new file mode 100644
index 0000000..d1f0331
--- /dev/null
+++ b/libs/bsapacker/tests/MockModDtoFactory.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IModDtoFactory.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockModDtoFactory : public IModDtoFactory
+{
+public:
+	MOCK_METHOD(std::unique_ptr<IModDto>, Create, (), (const));
+};
diff --git a/libs/bsapacker/tests/MockOrganizer.h b/libs/bsapacker/tests/MockOrganizer.h
new file mode 100644
index 0000000..4c6762e
--- /dev/null
+++ b/libs/bsapacker/tests/MockOrganizer.h
@@ -0,0 +1,61 @@
+#include "imoinfo.h"
+#include <gmock/gmock.h>
+
+using namespace MOBase;
+
+class MockOrganizer : public IOrganizer
+{
+public:
+	// clang-format off
+	MOCK_METHOD(IModRepositoryBridge*, createNexusBridge, (), (const, override));
+	MOCK_METHOD(QString, profileName, (), (const, override));
+	MOCK_METHOD(QString, profilePath, (), (const, override));
+	MOCK_METHOD(QString, downloadsPath, (), (const, override));
+	MOCK_METHOD(QString, overwritePath, (), (const, override));
+	MOCK_METHOD(QString, basePath, (), (const, override));
+	MOCK_METHOD(QString, modsPath, (), (const, override));
+	MOCK_METHOD(Version, version, (), (const, override));
+	MOCK_METHOD(VersionInfo, appVersion, (), (const, override));
+	MOCK_METHOD(IModInterface*, createMod, (GuessedValue<QString> &name), (override));
+	MOCK_METHOD(IPluginGame*, getGame, (const QString &gameName), (const, override));
+	MOCK_METHOD(void, modDataChanged, (IModInterface *mod), (override));
+	MOCK_METHOD(QVariant, pluginSetting, (const QString &pluginName, const QString &key), (const, override));
+	MOCK_METHOD(void, setPluginSetting, (const QString &pluginName, const QString &key, const QVariant &value), (override));
+	MOCK_METHOD(bool, isPluginEnabled, (const QString& pluginName), (const, override));
+	MOCK_METHOD(bool, isPluginEnabled, (IPlugin *plugin), (const, override));
+	MOCK_METHOD(QVariant, persistent, (const QString &pluginName, const QString &key, const QVariant &def), (const, override));
+	MOCK_METHOD(void, setPersistent, (const QString &pluginName, const QString &key, const QVariant &value, bool sync), (override));
+	MOCK_METHOD(QString, pluginDataPath, (), (const, override));
+	MOCK_METHOD(IModInterface*, installMod, (const QString &fileName, const QString &nameSuggestion), (override));
+	MOCK_METHOD(QString, resolvePath, (const QString &fileName), (const, override));
+	MOCK_METHOD(QStringList, listDirectories, (const QString &directoryName), (const, override));
+	MOCK_METHOD(QStringList, findFiles, (const QString &path, const std::function<bool(const QString&)> &filter), (const, override));
+	MOCK_METHOD(QStringList, findFiles, (const QString &path, const QStringList &filter), (const, override));
+	MOCK_METHOD(QStringList, getFileOrigins, (const QString &fileName) ,(const, override));
+	MOCK_METHOD(QList<FileInfo>, findFileInfos, (const QString &path, const std::function<bool(const FileInfo&)> &filter), (const, override));
+	MOCK_METHOD(std::shared_ptr<const IFileTree>, virtualFileTree, (), (const, override));
+	MOCK_METHOD(MOBase::IDownloadManager*, downloadManager, (), (const, override));
+	MOCK_METHOD(MOBase::IPluginList*, pluginList, (), (const, override));
+	MOCK_METHOD(MOBase::IModList*, modList, (), (const, override));
+	MOCK_METHOD(MOBase::IProfile*, profile, (), (const, override));
+	MOCK_METHOD(IGameFeatures*, gameFeatures, (), (const, override));
+	MOCK_METHOD(HANDLE, startApplication, (const QString &executable, const QStringList &args, const QString &cwd, const QString &profile, const QString &forcedCustomOverwrite, bool ignoreCustomOverwrite), (override));
+	MOCK_METHOD(bool, waitForApplication, (HANDLE handle, bool refresh, LPDWORD exitCode), (const, override));
+	MOCK_METHOD(bool, onAboutToRun, (const std::function<bool(const QString&)> &func), (override));
+	MOCK_METHOD(bool, onAboutToRun, (const std::function<bool(const QString&, const QDir&, const QString&)>&), (override));
+	MOCK_METHOD(bool, onFinishedRun, (const std::function<void(const QString&, unsigned int)> &func), (override));
+	MOCK_METHOD(void, refresh, (bool saveChanges), (override));
+	MOCK_METHOD(MOBase::IPluginGame const *, managedGame, (), (const, override));
+	MOCK_METHOD(bool, onUserInterfaceInitialized, (const std::function<void (QMainWindow *)> &), (override));
+	MOCK_METHOD(bool, onNextRefresh, (const std::function<void()> &, bool), (override));
+	MOCK_METHOD(bool, onProfileCreated, (const std::function<void(MOBase::IProfile*)>&), (override));
+	MOCK_METHOD(bool, onProfileRemoved, (const std::function<void(const QString&)>&), (override));
+	MOCK_METHOD(bool, onProfileRenamed, (const std::function<void(MOBase::IProfile*, QString const&, QString const&)>&), (override));
+	MOCK_METHOD(bool, onProfileChanged, (const std::function<void (MOBase::IProfile*, MOBase::IProfile*)> &), (override));
+	MOCK_METHOD(bool, onPluginSettingChanged, (const std::function<void (const QString &,const QString &,const QVariant &,const QVariant &)> &), (override));
+	MOCK_METHOD(bool, onPluginEnabled, (const std::function<void(const MOBase::IPlugin*)>&), (override));
+	MOCK_METHOD(bool, onPluginEnabled, (const QString&, const std::function<void()>&), (override));
+	MOCK_METHOD(bool, onPluginDisabled, (const std::function<void(const MOBase::IPlugin*)>&), (override));
+	MOCK_METHOD(bool, onPluginDisabled, (const QString&, const std::function<void()>&), (override));
+	// clang-format on
+};
diff --git a/libs/bsapacker/tests/MockOverrideFileService.h b/libs/bsapacker/tests/MockOverrideFileService.h
new file mode 100644
index 0000000..b7c0414
--- /dev/null
+++ b/libs/bsapacker/tests/MockOverrideFileService.h
@@ -0,0 +1,10 @@
+#include <bsapacker/IOverrideFileService.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockOverrideFileService : public IOverrideFileService
+{
+public:
+    MOCK_METHOD(bool, CreateOverrideFile, (const int nexusId, const QString &modPath, const QStringList &archiveNames), (const, override));
+};
diff --git a/libs/bsapacker/tests/MockPackerDialog.h b/libs/bsapacker/tests/MockPackerDialog.h
new file mode 100644
index 0000000..aafad52
--- /dev/null
+++ b/libs/bsapacker/tests/MockPackerDialog.h
@@ -0,0 +1,17 @@
+#include <bsapacker/IPackerDialog.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockPackerDialog : public IPackerDialog
+{
+public:
+	MOCK_METHOD(bool, IsNewFilename, (), (const, override));
+	MOCK_METHOD(QString, SelectedMod, (), (const, override));
+	MOCK_METHOD(void, RefreshModList, (), (override));
+	MOCK_METHOD(QString, SelectedPluginItem, (), (const, override));
+	MOCK_METHOD(void, UpdateNameList, (const QString&), (override));
+	MOCK_METHOD(void, RefreshSelectedName, (), (override));
+	MOCK_METHOD(int, Exec, (), (override));
+	MOCK_METHOD(void, RefreshOkButton, (), (override));
+};
diff --git a/libs/bsapacker/tests/MockSettingsService.h b/libs/bsapacker/tests/MockSettingsService.h
new file mode 100644
index 0000000..73bfea0
--- /dev/null
+++ b/libs/bsapacker/tests/MockSettingsService.h
@@ -0,0 +1,10 @@
+#include <bsapacker/ISettingsService.h>
+#include <gmock/gmock.h>
+
+using namespace BsaPacker;
+
+class MockSettingsService : public ISettingsService
+{
+public:
+	MOCK_METHOD(QVariant, GetPluginSetting, (const QString&), (const, override));
+};
diff --git a/libs/bsapacker/tests/ModContextFacts.cpp b/libs/bsapacker/tests/ModContextFacts.cpp
new file mode 100644
index 0000000..3ab1808
--- /dev/null
+++ b/libs/bsapacker/tests/ModContextFacts.cpp
@@ -0,0 +1,33 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "ModContext.h"
+#include "MockOrganizer.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class ModContextFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockOrganizer = new NaggyMock<MockOrganizer>();
+		}
+
+		void TearDown() override {
+			delete naggyMockOrganizer;
+		}
+
+		NaggyMock<MockOrganizer>* naggyMockOrganizer;
+	};
+
+	TEST_F(ModContextFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = ModContext(
+				naggyMockOrganizer);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/ModDtoFactoryFacts.cpp b/libs/bsapacker/tests/ModDtoFactoryFacts.cpp
new file mode 100644
index 0000000..ae9a9f7
--- /dev/null
+++ b/libs/bsapacker/tests/ModDtoFactoryFacts.cpp
@@ -0,0 +1,53 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/ModDtoFactory.h>
+#include "MockModContext.h"
+#include "MockPackerDialog.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+using ::testing::Return;
+
+namespace BsaPackerTests
+{
+	class ModDtoFactoryFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockModContext = new NaggyMock<MockModContext>();
+			naggyMockPackerDialog = new NaggyMock<MockPackerDialog>();
+		}
+
+		void TearDown() override {
+			delete naggyMockModContext;
+			delete naggyMockPackerDialog;
+		}
+
+		NaggyMock<MockModContext>* naggyMockModContext;
+		NaggyMock<MockPackerDialog>* naggyMockPackerDialog;
+	};
+
+	TEST_F(ModDtoFactoryFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(ModDtoFactory(
+			naggyMockModContext,
+			naggyMockPackerDialog));
+	}
+
+	TEST_F(ModDtoFactoryFacts, Create_WhenGameIsNewVegas_ReturnsNewVegasIdInDto)
+	{
+		// Arrange
+		auto sut = ModDtoFactory(
+			naggyMockModContext,
+			naggyMockPackerDialog);
+		ON_CALL(*naggyMockModContext, GetNexusId())
+			.WillByDefault(Return(1));
+		ON_CALL(*naggyMockPackerDialog, Exec())
+			.WillByDefault(Return(QDialog::DialogCode::Accepted));
+
+		auto result = sut.Create();
+
+		EXPECT_EQ(1, result->NexusId());
+	}
+}
diff --git a/libs/bsapacker/tests/NewVegasDummyPluginServiceFacts.cpp b/libs/bsapacker/tests/NewVegasDummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..98216ff
--- /dev/null
+++ b/libs/bsapacker/tests/NewVegasDummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "NewVegasDummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class NewVegasDummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(NewVegasDummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = NewVegasDummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/OblivionDummyPluginServiceFacts.cpp b/libs/bsapacker/tests/OblivionDummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..dbebbb1
--- /dev/null
+++ b/libs/bsapacker/tests/OblivionDummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "OblivionDummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class OblivionDummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(OblivionDummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = OblivionDummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/SkyrimDummyPluginServiceFacts.cpp b/libs/bsapacker/tests/SkyrimDummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..e699c10
--- /dev/null
+++ b/libs/bsapacker/tests/SkyrimDummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "SkyrimDummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class SkyrimDummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(SkyrimDummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = SkyrimDummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/SkyrimSEDummyPluginServiceFacts.cpp b/libs/bsapacker/tests/SkyrimSEDummyPluginServiceFacts.cpp
new file mode 100644
index 0000000..5a67937
--- /dev/null
+++ b/libs/bsapacker/tests/SkyrimSEDummyPluginServiceFacts.cpp
@@ -0,0 +1,39 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "SkyrimSEDummyPluginService.h"
+#include "MockFileWriterService.h"
+#include "MockDummyPluginLogic.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class SkyrimSEDummyPluginServiceFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockFileWriterService = new NaggyMock<MockFileWriterService>();
+			naggyMockDummyPluginLogic = new NaggyMock<MockDummyPluginLogic>();
+		}
+
+		void TearDown() override {
+			delete naggyMockFileWriterService;
+			delete naggyMockDummyPluginLogic;
+		}
+
+		NaggyMock<MockFileWriterService>* naggyMockFileWriterService;
+		NaggyMock<MockDummyPluginLogic>* naggyMockDummyPluginLogic;
+	};
+
+	TEST_F(SkyrimSEDummyPluginServiceFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = SkyrimSEDummyPluginService(
+				naggyMockFileWriterService,
+				naggyMockDummyPluginLogic
+			);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/TextureArchiveBuilderFacts.cpp b/libs/bsapacker/tests/TextureArchiveBuilderFacts.cpp
new file mode 100644
index 0000000..3ada0de
--- /dev/null
+++ b/libs/bsapacker/tests/TextureArchiveBuilderFacts.cpp
@@ -0,0 +1,35 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/TextureArchiveBuilder.h>
+#include "MockArchiveBuilderHelper.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class TextureArchiveBuilderFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockArchiveBuilderHelper = new NaggyMock<MockArchiveBuilderHelper>();
+		}
+
+		void TearDown() override {
+			delete naggyMockArchiveBuilderHelper;
+		}
+
+		NaggyMock<MockArchiveBuilderHelper>* naggyMockArchiveBuilderHelper;
+	};
+
+	TEST_F(TextureArchiveBuilderFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = TextureArchiveBuilder(
+				naggyMockArchiveBuilderHelper,
+				QDir(),
+				baNone);
+		);
+	}
+}
diff --git a/libs/bsapacker/tests/TexturelessArchiveBuilderFacts.cpp b/libs/bsapacker/tests/TexturelessArchiveBuilderFacts.cpp
new file mode 100644
index 0000000..f0aa7d2
--- /dev/null
+++ b/libs/bsapacker/tests/TexturelessArchiveBuilderFacts.cpp
@@ -0,0 +1,35 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <bsapacker/TexturelessArchiveBuilder.h>
+#include "MockArchiveBuilderHelper.h"
+
+using namespace BsaPacker;
+using ::testing::NaggyMock;
+
+namespace BsaPackerTests
+{
+	class TexturelessArchiveBuilderFacts : public ::testing::Test
+	{
+	protected:
+		void SetUp() override {
+			naggyMockArchiveBuilderHelper = new NaggyMock<MockArchiveBuilderHelper>();
+		}
+
+		void TearDown() override {
+			delete naggyMockArchiveBuilderHelper;
+		}
+
+		NaggyMock<MockArchiveBuilderHelper>* naggyMockArchiveBuilderHelper;
+	};
+
+	TEST_F(TexturelessArchiveBuilderFacts, Ctor_Always_Constructs)
+	{
+		EXPECT_NO_THROW(
+			auto result = TexturelessArchiveBuilder(
+				naggyMockArchiveBuilderHelper,
+				QDir(),
+				baNone);
+		);
+	}
+}