Umhüllung einer API zur Unterstützung der Injektion von Abhängigkeiten

Question

Ich interagiere mit einer API, die nur statische Funktionen hat und nicht geöffnet und geändert werden kann.

    public class WindowsNativeGraphAPI
    {
        public static IEnumerable<IGraphData> GetGraphData();
        public static bool DeleteGraphData(IGraphData data);
    }

Ich möchte in der Lage sein, die API in eine Funktion oder einen Konstruktor zu übergeben und die Abhängigkeitsinjektion einzuhalten (nur für den Fall, dass wir die API später auswechseln).

public void GatherGraphData(IGraphAPI api)
{...}

Damit diese API als Parameter übergeben werden kann, müsste ich zumindest abstrahieren, um eine Schnittstelle zur Übergabe an die Funktion zu verwenden.

    public interface IGraphAPI
    {
        IEnumerable<IGraphData> GetGraphData();
        bool DeleteGraphData(IGraphData data);
    }

Allerdings müsste ich dann die Schnittstelle in einer anderen Klasse implementieren, da ich die ursprüngliche API nicht ändern kann. Diese Klasse wäre ein leichtgewichtiger Wrapper um die API, der lediglich die entsprechende Funktion der API aufruft und das gleiche Ergebnis zurückgibt.

    public class WindowsGraphAPI : IGraphAPI
    {
        public IEnumerable<IGraphData> GetGraphData()
        {
            return WindowsNativeGraphAPI.GetGraphData();
        }

        public bool DeleteGraphData(IGraphData data)
        {
            return WindowsNativeGraphAPI.DeleteGraphData(data)
        }
    }

Ich mag die Idee nicht, eine weitere Klasse zu erstellen, um die API zu umhüllen. Ich verstehe, dass dieser Wrapper sehr leicht sein würde und nur die Ergebnisse der API zurückgeben würde, aber wie teste ich den Wrapper? Der Wrapper sollte wahrscheinlich auch eine Ausnahmebehandlung enthalten, um mit Fehlern in der API umgehen zu können. Wenn wir zu einer anderen API wechseln würden, die unter demselben Problem leidet, müssten wir diese zusätzlichen Klassen und Schnittstellen erneut erstellen.

Im Idealfall wäre das Endergebnis eine nachahmungsfähige API, die beim Schreiben der Unit-Tests für die neue Komponente, die sie nutzt, verwendet werden kann.

Ist dies die richtige Vorgehensweise? Kann es auch anders gemacht werden?

Danke