在Swift中模拟singleton / sharedInstance

public class MyClass: NSObject {
    func method() {
         // Do something...
         // ...
         SingletonClass.sharedInstance.callMethod()
    }
}

该类使用以下形式实现的单例：

public class SingletonClass: NSObject {

    // Only accessible using singleton
    static let sharedInstance = SingletonClass()

    private override init() {
        super.init()
    }

    func callMethod() {
        // Do something crazy that shouldn't run under tests
    }
}

现在进行测试.我想测试该方法()实际上做了它应该做的事情,但我不想调用callMethod()中的代码(因为它做了一些不应该在测试中运行的可怕的异步/网络/线程的东西MyClass,并将使测试崩溃).

所以我基本上想做的是：

SingletonClass = mockSingletonClass: SingletonClass {
    override func callMethod() {
        // Do nothing
    }
let myObject = MyClass()
myObject.method()
// check if tests passed

这显然是无效的Swift,但你明白了.我怎样才能为这个特定的测试覆盖callMethod(),使其无害？

编辑：我尝试使用依赖注入的形式解决这个问题,但遇到了大问题.我创建了一个自定义初始化方法,仅用于测试,以便我可以像这样创建我的对象：

let myObject = MyClass(singleton: mockSingletonClass)

让MyClass看起来像这样

public class MyClass: NSObject {
    let singleton: SingletonClass

    init(mockSingleton: SingletonClass){
        self.singleton = mockSingleton
    }

    init() {
        singleton = SingletonClass.sharedInstance
    }

    func method() {
         // Do something...
         // ...
         singleton.callMethod()
    }
}

将测试代码与其余代码混合是我觉得有点不愉快,但没关系. BIG的问题是我在我的项目中有两个像这样构建的单身人士,他们互相引用：

public class FirstSingletonClass: NSObject {
    // Only accessible using singleton
    static let sharedInstance = FirstSingletonClass()

    let secondSingleton: SecondSingletonClass

    init(mockSingleton: SecondSingletonClass){
        self.secondSingleton = mockSingleton
    }

    private override init() {
        secondSingleton = SecondSingletonClass.sharedInstance
        super.init()
    }

    func someMethod(){
        // Use secondSingleton
    }
}

public class SecondSingletonClass: NSObject {
    // Only accessible using singleton
    static let sharedInstance = SecondSingletonClass()

    let firstSingleton: FirstSingletonClass

    init(mockSingleton: FirstSingletonClass){
        self.firstSingleton = mockSingleton
    }

    private override init() {
        firstSingleton = FirstSingletonClass.sharedInstance
        super.init()
    }

    func someOtherMethod(){
        // Use firstSingleton
    }
}

当第一个使用的单例之一,init方法等待另一个的init方法时,这会造成死锁,依此类推……