Add libusbwrapper for unit tests and UsbDevice unit tests

src/core/PrinterService.cpp

@@ -22,13 +22,19 @@
 #include <spdlog/spdlog.h>
 
 #include "core/PrinterDriverFactory.hpp"
+#include "libusbwrap/UsbDeviceFactory.hpp"
 
 namespace ptprnt::core {
 
-PrinterService::PrinterService() = default;
+// Default constructor delegates to DI constructor
+PrinterService::PrinterService() : PrinterService(std::make_unique<libusbwrap::UsbDeviceFactory>()) {}
+
+// Constructor with dependency injection
+PrinterService::PrinterService(std::unique_ptr<libusbwrap::IUsbDeviceFactory> usbFactory)
+    : mUsbDeviceFactory(std::move(usbFactory)) {}
 
 bool PrinterService::initialize() {
-    if (!mUsbDeviceFactory.init()) {
+    if (!mUsbDeviceFactory->init()) {
         spdlog::error("Could not initialize libusb");
         return false;
     }
@@ -38,7 +44,7 @@ bool PrinterService::initialize() {
 std::vector<std::shared_ptr<IPrinterDriver>> PrinterService::detectPrinters() {
     spdlog::debug("Detecting printers...");
 
-    auto usbDevs       = mUsbDeviceFactory.findAllDevices();
+    auto usbDevs       = mUsbDeviceFactory->findAllDevices();
     auto driverFactory = std::make_unique<PrinterDriverFactory>();
     mDetectedPrinters.clear();
 

src/core/PrinterService.hpp

@@ -24,7 +24,7 @@
 #include <vector>
 
 #include "interface/IPrinterService.hpp"
-#include "libusbwrap/UsbDeviceFactory.hpp"
+#include "libusbwrap/interface/IUsbDeviceFactory.hpp"
 #include "printers/interface/IPrinterDriver.hpp"
 
 namespace ptprnt::core {
@@ -40,7 +40,12 @@ namespace ptprnt::core {
  */
 class PrinterService : public IPrinterService {
    public:
+    // Default constructor (uses real UsbDeviceFactory)
     PrinterService();
+
+    // Constructor for testing (inject mock factory)
+    explicit PrinterService(std::unique_ptr<libusbwrap::IUsbDeviceFactory> usbFactory);
+
     ~PrinterService() override = default;
 
     PrinterService(const PrinterService&)            = delete;
@@ -81,7 +86,7 @@ class PrinterService : public IPrinterService {
     bool printLabel(std::unique_ptr<graphics::ILabel> label) override;
 
    private:
-    libusbwrap::UsbDeviceFactory mUsbDeviceFactory;
+    std::unique_ptr<libusbwrap::IUsbDeviceFactory> mUsbDeviceFactory;
     std::vector<std::shared_ptr<IPrinterDriver>> mDetectedPrinters;
     std::shared_ptr<IPrinterDriver> mCurrentPrinter;
 };

src/libusbwrap/LibusbWrapper.cpp

@@ -0,0 +1,108 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "LibusbWrapper.hpp"
+
+#include "libusb.h"
+
+namespace libusbwrap {
+
+// LibusbDeviceDeleter implementation
+void LibusbDeviceDeleter::operator()(libusb_device* dev) const {
+    if (dev && wrapper) {
+        wrapper->unrefDevice(dev);
+    }
+}
+
+// LibusbWrapper implementation - thin forwarding to libusb C API
+
+int LibusbWrapper::init(libusb_context** ctx) {
+    return libusb_init(ctx);
+}
+
+void LibusbWrapper::exit(libusb_context* ctx) {
+    libusb_exit(ctx);
+}
+
+ssize_t LibusbWrapper::getDeviceList(libusb_context* ctx, libusb_device*** list) {
+    return libusb_get_device_list(ctx, list);
+}
+
+void LibusbWrapper::freeDeviceList(libusb_device** list, int unrefDevices) {
+    libusb_free_device_list(list, unrefDevices);
+}
+
+void LibusbWrapper::refDevice(libusb_device* dev) {
+    libusb_ref_device(dev);
+}
+
+void LibusbWrapper::unrefDevice(libusb_device* dev) {
+    libusb_unref_device(dev);
+}
+
+int LibusbWrapper::getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) {
+    return libusb_get_device_descriptor(dev, desc);
+}
+
+int LibusbWrapper::open(libusb_device* dev, libusb_device_handle** handle) {
+    return libusb_open(dev, handle);
+}
+
+void LibusbWrapper::close(libusb_device_handle* handle) {
+    libusb_close(handle);
+}
+
+int LibusbWrapper::getSpeed(libusb_device* dev) {
+    return libusb_get_device_speed(dev);
+}
+
+uint8_t LibusbWrapper::getBusNumber(libusb_device* dev) {
+    return libusb_get_bus_number(dev);
+}
+
+uint8_t LibusbWrapper::getPortNumber(libusb_device* dev) {
+    return libusb_get_port_number(dev);
+}
+
+int LibusbWrapper::kernelDriverActive(libusb_device_handle* handle, int interfaceNo) {
+    return libusb_kernel_driver_active(handle, interfaceNo);
+}
+
+int LibusbWrapper::detachKernelDriver(libusb_device_handle* handle, int interfaceNo) {
+    return libusb_detach_kernel_driver(handle, interfaceNo);
+}
+
+int LibusbWrapper::claimInterface(libusb_device_handle* handle, int interfaceNo) {
+    return libusb_claim_interface(handle, interfaceNo);
+}
+
+int LibusbWrapper::releaseInterface(libusb_device_handle* handle, int interfaceNo) {
+    return libusb_release_interface(handle, interfaceNo);
+}
+
+int LibusbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length,
+                                 int* transferred, unsigned int timeout) {
+    return libusb_bulk_transfer(handle, endpoint, data, length, transferred, timeout);
+}
+
+const char* LibusbWrapper::errorName(int errorCode) {
+    return libusb_error_name(errorCode);
+}
+
+}  // namespace libusbwrap

src/libusbwrap/LibusbWrapper.hpp

@@ -0,0 +1,129 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+// Forward declarations to avoid pulling in libusb.h in header
+struct libusb_context;
+struct libusb_device;
+struct libusb_device_handle;
+struct libusb_device_descriptor;
+
+namespace libusbwrap {
+
+// Forward declaration
+class ILibusbWrapper;
+
+// Custom deleter for libusb_device that uses the wrapper
+// Implementation in LibusbWrapper.cpp
+struct LibusbDeviceDeleter {
+    std::shared_ptr<ILibusbWrapper> wrapper;
+    void operator()(libusb_device* dev) const;
+};
+using LibusbDevicePtr = std::unique_ptr<libusb_device, LibusbDeviceDeleter>;
+
+/**
+ * @brief Thin wrapper around libusb C API
+ *
+ * This class provides a 1:1 mapping to libusb C functions.
+ * NO LOGIC - just wraps the C calls directly.
+ * All logic (RAII, error handling, etc.) belongs in UsbDevice/UsbDeviceFactory.
+ */
+class ILibusbWrapper {
+   public:
+    virtual ~ILibusbWrapper() = default;
+
+    // Context management (raw pointers - caller manages lifecycle)
+    virtual int init(libusb_context** ctx) = 0;
+    virtual void exit(libusb_context* ctx) = 0;
+
+    // Device enumeration (raw pointers - caller manages lifecycle)
+    virtual ssize_t getDeviceList(libusb_context* ctx, libusb_device*** list) = 0;
+    virtual void freeDeviceList(libusb_device** list, int unrefDevices) = 0;
+    virtual void refDevice(libusb_device* dev) = 0;
+    virtual void unrefDevice(libusb_device* dev) = 0;
+
+    // Device descriptor
+    virtual int getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) = 0;
+
+    // Device opening/closing (raw pointers - caller manages lifecycle)
+    virtual int open(libusb_device* dev, libusb_device_handle** handle) = 0;
+    virtual void close(libusb_device_handle* handle) = 0;
+
+    // Device information
+    virtual int getSpeed(libusb_device* dev) = 0;
+    virtual uint8_t getBusNumber(libusb_device* dev) = 0;
+    virtual uint8_t getPortNumber(libusb_device* dev) = 0;
+
+    // Kernel driver management
+    virtual int kernelDriverActive(libusb_device_handle* handle, int interfaceNo) = 0;
+    virtual int detachKernelDriver(libusb_device_handle* handle, int interfaceNo) = 0;
+
+    // Interface management
+    virtual int claimInterface(libusb_device_handle* handle, int interfaceNo) = 0;
+    virtual int releaseInterface(libusb_device_handle* handle, int interfaceNo) = 0;
+
+    // Data transfer
+    virtual int bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length,
+                             int* transferred, unsigned int timeout) = 0;
+
+    // Error handling
+    virtual const char* errorName(int errorCode) = 0;
+};
+
+/**
+ * @brief Concrete implementation - thin wrapper forwarding to libusb C API
+ */
+class LibusbWrapper : public ILibusbWrapper {
+   public:
+    int init(libusb_context** ctx) override;
+    void exit(libusb_context* ctx) override;
+
+    ssize_t getDeviceList(libusb_context* ctx, libusb_device*** list) override;
+    void freeDeviceList(libusb_device** list, int unrefDevices) override;
+    void refDevice(libusb_device* dev) override;
+    void unrefDevice(libusb_device* dev) override;
+
+    int getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) override;
+
+    int open(libusb_device* dev, libusb_device_handle** handle) override;
+    void close(libusb_device_handle* handle) override;
+
+    int getSpeed(libusb_device* dev) override;
+    uint8_t getBusNumber(libusb_device* dev) override;
+    uint8_t getPortNumber(libusb_device* dev) override;
+
+    int kernelDriverActive(libusb_device_handle* handle, int interfaceNo) override;
+    int detachKernelDriver(libusb_device_handle* handle, int interfaceNo) override;
+
+    int claimInterface(libusb_device_handle* handle, int interfaceNo) override;
+    int releaseInterface(libusb_device_handle* handle, int interfaceNo) override;
+
+    int bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length, int* transferred,
+                     unsigned int timeout) override;
+
+    const char* errorName(int errorCode) override;
+};
+
+}  // namespace libusbwrap

src/libusbwrap/UsbDevice.cpp

@@ -24,44 +24,57 @@
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/LibusbWrapper.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
-UsbDevice::UsbDevice(libusb_context* ctx, usbDevice_ptr dev) : mLibusbCtx(ctx), mLibusbDev(std::move(dev)) {
-    if (mLibusbCtx == nullptr || mLibusbDev == nullptr) {
-        throw std::invalid_argument("ctx or device are nullptr");
-    }
 
-    libusb_get_device_descriptor(mLibusbDev.get(), &mLibusbDevDesc);
+// Default constructor delegates to DI constructor
+UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc)
+    : UsbDevice(device, desc, std::make_shared<LibusbWrapper>()) {}
+
+// Constructor with dependency injection
+UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc,
+                     std::shared_ptr<ILibusbWrapper> libusbWrapper)
+    : mLibusb(libusbWrapper),
+      mDevice(device, LibusbDeviceDeleter{libusbWrapper}),
+      mDeviceDescriptor(desc) {
+    if (!mDevice) {
+        throw std::invalid_argument("device is nullptr");
+    }
 }
 
 UsbDevice::~UsbDevice() {
-    // only free the device, not the context, which is shared between every device
-    // the UsbDeviceFactory will take care of that
-    if (mIsOpen) {
-        close();
+    if (mIsOpen && mDeviceHandle) {
+        mLibusb->close(mDeviceHandle);
     }
+    // mDevice auto-deleted by unique_ptr (calls LibusbDeviceDeleter)
 }
 
 bool UsbDevice::open() {
-    int openStatus = libusb_open(mLibusbDev.get(), &mLibusbDevHandle);
+    int openStatus = mLibusb->open(mDevice.get(), &mDeviceHandle);
     if (openStatus != 0) {
         mLastError = static_cast<Error>(openStatus);
         return false;
     }
 
+    mIsOpen = true;
     return true;
 }
 
 void UsbDevice::close() {
-    libusb_close(mLibusbDevHandle);
+    if (mDeviceHandle) {
+        mLibusb->close(mDeviceHandle);
+        mDeviceHandle = nullptr;
+        mIsOpen       = false;
+    }
 }
 
 bool UsbDevice::detachKernelDriver(int interfaceNo) {
     // TODO: cover the other status codes that can be returned
-    int kernelDriverStatus = libusb_kernel_driver_active(mLibusbDevHandle, interfaceNo);
+    int kernelDriverStatus = mLibusb->kernelDriverActive(mDeviceHandle, interfaceNo);
     if (kernelDriverStatus == 1) {  // kernel driver is active, we have to detach to continue...
-        int detachStatus = libusb_detach_kernel_driver(mLibusbDevHandle, interfaceNo);
+        int detachStatus = mLibusb->detachKernelDriver(mDeviceHandle, interfaceNo);
         if (detachStatus != 0) {
             mLastError = static_cast<Error>(detachStatus);
             return false;
@@ -73,7 +86,7 @@ bool UsbDevice::detachKernelDriver(int interfaceNo) {
 
 bool UsbDevice::claimInterface(int interfaceNo) {
     // TODO: cover the other status codes that can be returned
-    int claimInterfaceStatus = libusb_claim_interface(mLibusbDevHandle, interfaceNo);
+    int claimInterfaceStatus = mLibusb->claimInterface(mDeviceHandle, interfaceNo);
     if (claimInterfaceStatus != 0) {
         mLastError = static_cast<Error>(claimInterfaceStatus);
         return false;
@@ -82,7 +95,7 @@ bool UsbDevice::claimInterface(int interfaceNo) {
 }
 
 bool UsbDevice::releaseInterface(int interfaceNo) {
-    int releaseInterfaceStatus = libusb_release_interface(mLibusbDevHandle, interfaceNo);
+    int releaseInterfaceStatus = mLibusb->releaseInterface(mDeviceHandle, interfaceNo);
     if (releaseInterfaceStatus != 0) {
         mLastError = static_cast<Error>(releaseInterfaceStatus);
         return false;
@@ -92,10 +105,8 @@ bool UsbDevice::releaseInterface(int interfaceNo) {
 
 bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) {
     // TODO: implement error handling for incomplete transactions (tx length != data length)
-    int bulkTransferStatus = 0;
-
-    bulkTransferStatus = libusb_bulk_transfer(mLibusbDevHandle, endpoint, const_cast<unsigned char*>(data.data()),
-                                              data.size(), tx, timeout);
+    int bulkTransferStatus = mLibusb->bulkTransfer(mDeviceHandle, endpoint, const_cast<unsigned char*>(data.data()),
+                                                   data.size(), tx, timeout);
     if (bulkTransferStatus != 0) {
         mLastError = static_cast<Error>(bulkTransferStatus);
         return false;
@@ -104,19 +115,19 @@ bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data,
 }
 
 const usbId UsbDevice::getUsbId() {
-    return {mLibusbDevDesc.idVendor, mLibusbDevDesc.idProduct};
+    return {mDeviceDescriptor.idVendor, mDeviceDescriptor.idProduct};
 }
 
 const device::Speed UsbDevice::getSpeed() {
-    return static_cast<device::Speed>(libusb_get_device_speed(mLibusbDev.get()));
+    return static_cast<device::Speed>(mLibusb->getSpeed(mDevice.get()));
 }
 
 const uint8_t UsbDevice::getBusNumber() {
-    return libusb_get_bus_number(mLibusbDev.get());
+    return mLibusb->getBusNumber(mDevice.get());
 }
 
 const uint8_t UsbDevice::getPortNumber() {
-    return libusb_get_port_number(mLibusbDev.get());
+    return mLibusb->getPortNumber(mDevice.get());
 }
 
 const Error UsbDevice::getLastError() {
@@ -124,6 +135,6 @@ const Error UsbDevice::getLastError() {
 }
 
 const std::string UsbDevice::getLastErrorString() {
-    return std::string(libusb_error_name(static_cast<int>(mLastError)));
+    return std::string(mLibusb->errorName(static_cast<int>(mLastError)));
 }
 }  // namespace libusbwrap

src/libusbwrap/UsbDevice.hpp

@@ -24,23 +24,20 @@
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
+#include "libusbwrap/LibusbWrapper.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
 
-struct usbDevice_deleter {
-    void operator()(libusb_device* dev_ptr) const {
-        if (nullptr != dev_ptr) {
-            libusb_unref_device(dev_ptr);
-        }
-    }
-};
-
-using usbDevice_ptr = std::unique_ptr<libusb_device, usbDevice_deleter>;
-
 class UsbDevice : public IUsbDevice {
    public:
-    explicit UsbDevice(libusb_context* ctx, usbDevice_ptr dev);
+    // Default constructor (uses real LibusbWrapper)
+    UsbDevice(libusb_device* device, const libusb_device_descriptor& desc);
+
+    // Constructor for testing (inject mock wrapper)
+    UsbDevice(libusb_device* device, const libusb_device_descriptor& desc,
+              std::shared_ptr<ILibusbWrapper> libusbWrapper);
+
     ~UsbDevice() override;
 
     // delete copy ctor and assignment
@@ -69,10 +66,13 @@ class UsbDevice : public IUsbDevice {
     const std::string getLastErrorString() override;
 
    private:
-    libusb_context* mLibusbCtx{nullptr};
-    usbDevice_ptr mLibusbDev{nullptr};
-    libusb_device_handle* mLibusbDevHandle{nullptr};
-    libusb_device_descriptor mLibusbDevDesc{0};
+    std::shared_ptr<ILibusbWrapper> mLibusb;  // Injectable wrapper
+
+    // RAII wrappers (UsbDevice owns the lifecycle logic)
+    LibusbDevicePtr mDevice;                       // unique_ptr with custom deleter
+    libusb_device_handle* mDeviceHandle = nullptr;  // Managed by UsbDevice (calls mLibusb->close())
+
+    libusb_device_descriptor mDeviceDescriptor{0};
     std::atomic<bool> mIsOpen = false;
     Error mLastError          = Error::SUCCESS;
 };

src/libusbwrap/UsbDeviceFactory.cpp

@@ -27,16 +27,25 @@
 #include <vector>
 
 #include "libusb.h"
+#include "libusbwrap/LibusbWrapper.hpp"
 #include "libusbwrap/UsbDevice.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
 
+// Default constructor delegates to DI constructor
+UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared<LibusbWrapper>()) {}
+
+// Constructor with dependency injection
+UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibusbWrapper> libusbWrapper)
+    : mLibusb(std::move(libusbWrapper)) {}
+
 UsbDeviceFactory::~UsbDeviceFactory() {
-    if (mLibusbCtx) {
-        libusb_exit(mLibusbCtx);
+    mDeviceList.clear();  // Release devices first
+    if (mContext) {
+        mLibusb->exit(mContext);
     }
-};
+}
 
 std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findAllDevices() {
     refreshDeviceList();
@@ -51,46 +60,51 @@ std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findDevices(uint16_t
 ssize_t UsbDeviceFactory::refreshDeviceList() {
     libusb_device** list{nullptr};
 
-    ssize_t ret = libusb_get_device_list(mLibusbCtx, &list);
-    mLibusbDeviceList.clear();
-    if (ret < 0) {
-        spdlog::error("Error enumarating USB devices");
-    } else if (ret == 0) {
+    ssize_t count = mLibusb->getDeviceList(mContext, &list);
+    mDeviceList.clear();
+
+    if (count < 0) {
+        spdlog::error("Error enumerating USB devices");
+    } else if (count == 0) {
         spdlog::warn("No USB devices found");
+    } else {
+        for (ssize_t i = 0; i < count; i++) {
+            mLibusb->refDevice(list[i]);  // Increment refcount
+            // Create LibusbDevicePtr with deleter that uses the wrapper
+            mDeviceList.emplace_back(list[i], LibusbDeviceDeleter{mLibusb});
+        }
     }
 
-    for (ssize_t i = 0; i < ret; i++) {
-        mLibusbDeviceList.emplace_back(list[i]);
-    }
-
-    libusb_free_device_list(list, false);
-    return ret;
+    mLibusb->freeDeviceList(list, false);  // Don't unref (we did that above)
+    return count;
 }
 
 std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVector(uint16_t vidMask, uint16_t pidMask,
                                                                                    uint16_t vid, uint16_t pid) {
     std::vector<std::unique_ptr<IUsbDevice>> matchedDevices;
     // see libusb/examples/listdevs.c
-    for (auto& currDev : mLibusbDeviceList) {
-        struct libusb_device_descriptor currDevDesc{};
+    for (auto& dev : mDeviceList) {
+        libusb_device_descriptor desc{};
 
-        int ret = libusb_get_device_descriptor(currDev.get(), &currDevDesc);
-        spdlog::trace("Detected Device {:04x}:{:04x} ", currDevDesc.idVendor, currDevDesc.idProduct);
-        if (ret < 0) {
-            continue;
-        }
-        if (((currDevDesc.idVendor & vidMask) == vid) && ((currDevDesc.idProduct & pidMask) == pid)) {
-            matchedDevices.push_back(std::make_unique<UsbDevice>(mLibusbCtx, std::move(currDev)));
+        int ret = mLibusb->getDeviceDescriptor(dev.get(), &desc);
+        spdlog::trace("Detected Device {:04x}:{:04x} ", desc.idVendor, desc.idProduct);
+
+        if (ret >= 0 && ((desc.idVendor & vidMask) == vid) && ((desc.idProduct & pidMask) == pid)) {
+            // Transfer ownership of device to UsbDevice
+            libusb_device* raw_dev = dev.release();
+
+            // Create UsbDevice with same wrapper instance
+            matchedDevices.push_back(std::make_unique<UsbDevice>(raw_dev, desc, mLibusb));
         }
     }
     return matchedDevices;
 }
 
 bool UsbDeviceFactory::init() {
-    auto err = libusb_init(&mLibusbCtx);
+    int err = mLibusb->init(&mContext);
 
     if (err != (int)Error::SUCCESS) {
-        spdlog::error("Could not intialize libusb");
+        spdlog::error("Could not initialize libusb");
         return false;
     }
 

src/libusbwrap/UsbDeviceFactory.hpp

@@ -20,8 +20,10 @@
 #pragma once
 
 #include <cstdint>
+#include <memory>
 
 #include "libusb.h"
+#include "libusbwrap/LibusbWrapper.hpp"
 #include "libusbwrap/UsbDevice.hpp"
 #include "libusbwrap/interface/IUsbDeviceFactory.hpp"
 
@@ -31,7 +33,12 @@ constexpr const uint16_t LIBUSB_BITMASK_ALL = 0xffff;
 
 class UsbDeviceFactory : public IUsbDeviceFactory {
    public:
-    UsbDeviceFactory() = default;
+    // Default constructor (uses real LibusbWrapper)
+    UsbDeviceFactory();
+
+    // Constructor for testing (inject mock wrapper)
+    explicit UsbDeviceFactory(std::shared_ptr<ILibusbWrapper> libusbWrapper);
+
     virtual ~UsbDeviceFactory();
 
     // delete copy ctor and assignment
@@ -40,17 +47,17 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
     UsbDeviceFactory(UsbDeviceFactory&&)            = delete;
     UsbDeviceFactory& operator=(UsbDeviceFactory&&) = delete;
 
-    bool init();
+    bool init() override;
     /**
      * @brief Gets all devices that are detected by libusb. Will allocate a shared_ptr for each Device
-     * 
+     *
      * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of all detected USB devices
      */
     std::vector<std::unique_ptr<IUsbDevice>> findAllDevices() override;
     /**
-     * @brief Gets all devices with certain vid/pid combination. 
+     * @brief Gets all devices with certain vid/pid combination.
      *        If only one device of certain type is connected, vector is usually only one element
-     * 
+     *
      * @param vid VendorId of the devices to find
      * @param pid ProductId of the devices to find
      * @return std::vector<std::shared_ptr<IUsbDevice>> Vector of detected USB devices based on vid/pid
@@ -64,8 +71,9 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
                                                                      uint16_t pidMask, uint16_t vid,
                                                                      uint16_t pid);
     // members
-    libusb_context* mLibusbCtx{nullptr};
-    std::vector<usbDevice_ptr> mLibusbDeviceList{};
+    std::shared_ptr<ILibusbWrapper> mLibusb;
+    libusb_context* mContext{nullptr};  // Factory manages lifecycle
+    std::vector<LibusbDevicePtr> mDeviceList{};
     bool mDeviceListInitialized = false;
 };
 }  // namespace libusbwrap

src/libusbwrap/interface/IUsbDeviceFactory.hpp

@@ -29,6 +29,7 @@ namespace libusbwrap {
 class IUsbDeviceFactory {
    public:
     virtual ~IUsbDeviceFactory()                                                             = default;
+    virtual bool init()                                                                      = 0;
     virtual std::vector<std::unique_ptr<IUsbDevice>> findAllDevices()                        = 0;
     virtual std::vector<std::unique_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) = 0;
 };

src/meson.build

@@ -7,6 +7,7 @@ ptprnt_hpps = files(
     'graphics/LabelBuilder.hpp',
     'graphics/Monochrome.hpp',
     'libusbwrap/LibUsbTypes.hpp',
+    'libusbwrap/LibusbWrapper.hpp',
     'libusbwrap/UsbDevice.hpp',
     'libusbwrap/UsbDeviceFactory.hpp',
     'libusbwrap/interface/IUsbDevice.hpp',
@@ -26,6 +27,7 @@ ptprnt_srcs = files(
     'graphics/Label.cpp',
     'graphics/LabelBuilder.cpp',
     'graphics/Monochrome.cpp',
+    'libusbwrap/LibusbWrapper.cpp',
     'libusbwrap/UsbDevice.cpp',
     'libusbwrap/UsbDeviceFactory.cpp',
     'printers/FakePrinter.cpp',