是否可以使用 Spock 存根或模拟 SocketChannel？

Question

基本上我有一个 Java 类，它在套接字通道上执行选择，我想存根通道以便我可以测试选择是否按预期工作。

例如，被测试的类大致是这样做的：

class TestedClass {
    TestedClass(SocketChannel socket) { this.socket = socket }

    // ...
    SocketChannel socket;
    // ...
    void foo() {
        // Wait a while for far end to close as it will report an error 
        // if we do it.  But don't wait forever! 
        // A -1 read means the socket was closed by the other end.
        // If we select on a read, we can check that, or time out 
        // after a reasonable delay.

        Selector selector = Selector.open();
        socket.configureBlocking(false);
        socket.register(selector, SelectionKey.OP_READ);
        while(selector.select(1000) == 0) {
            Log.debug("waiting for far end to close socket...")
        }

        ByteBuffer buffer = ByteBuffer.allocate(1);
        if (socket.read(buffer) >= 0) {
            Log.debug("far end didn't close");
            // The far end didn't close the connection, as we hoped
            abort(AbortCause.ServerClosed);
        }

        Log.debug("far end closed");
    }
}

我希望能够测试这样的东西：

def "test we don't shut prematurely" () {
    when:
    boolean wasClosedPrematurely
    SocketChannel socket = Stub(@SocketChannel) {
        // insert stub methods here ....
    }

    TestedClass tc = new TestedClass(socket)
    tc.foo();

    then:
    wasClosedPrematurely == false
}

这是基于一个真实的例子，但细节并不重要。总体目标是如何对支持选择的 SocketChannels 进行存根，这样我就不必创建一个真实的客户端来进行测试。

我也知道它比仅存根 SocketChannel 更复杂：似乎我需要拦截 Selector.open() 或以某种方式提供自定义系统默认 SelectorProvider。如果我只是简单地存根 SocketChannel，当我尝试将通过 Selection.open() 获得的选择器注册到我的存根时，我会得到一个 IllegalSelectorException，不幸的是，基本的 AbstractSelectableChannel#register 方法是最终的。

但是我找不到任何有用的指示来说明 Spock Mocks 如何或是否可以实现这一点，而且这似乎是一件很常见的事情，所以在这里提出一个很好的问题。有人可以帮忙吗？

Answer 1

Spock 使用CGLIB 模拟/存根/间谍类。 CGLIB 不能覆盖 final 方法。 SocketChannel 有很多 final 方法（例如 configureBlocking），但是 CGLIB 不会失败，而是使用原始方法。由于 configureBlocking 是最终的，它会在您的测试中使用。

public final SelectableChannel configureBlocking(boolean block) throws IOException { synchronized (regLock) { if (!isOpen()) throw new ClosedChannelException(); if (blocking == block) return this; if (block && haveValidKeys()) throw new IllegalBlockingModeException(); implConfigureBlocking(block); blocking = block; } return this; }

所以 configureBlocking 需要初始化 regLock 变量，但是当你为这个类创建存根时，变量没有初始化，你会在这里得到 NPE。

问题是如何处理它？ 好吧，我想说，首先，尝试使用接口而不是类。 如果不可能，请尽量不要调用 final 方法。 如果仍然不可能，您必须查看班级内部并找出应该嘲笑的内容。 我看到的最后一个选项是进行完整的集成测试：创建两个套接字并连接它们。

Answer 2

我想我可能已经找到了自己问题的答案。

所以Selector.open() 不能直接被拦截——但它只是调用SocketProvider.provider().openSelector()，而SocketProvider.provider() 是SocketProvider.provider 字段的惰性静态访问器。 （至少在我的情况下，Java 7）

因此，我们可以简单地设置这个provider 字段，即使它是私有的，因为Groovy 可以忽略正常的Java 可见性限制。一旦设置为我们自己的存根实例，以后所有的Selector.open() 调用都将使用它（需要注意的是这是一个全局更改，可能会影响其他未测试的代码）。

详细信息取决于您当时想要做什么，但如下所示，您可以返回其他类的存根，例如 AbstractSelectableChannel。

工作示例如下。

class SocketStubSpec extends Specification {

    SocketChannel makeSocketChannel(List events) {
        // Insert our stub SelectorProvider which stubs everything else
        // required, and records what happened in the events list.
        SelectorProvider.provider = Stub(SelectorProvider) {
            openSelector() >> {
                Map<SelectionKey, AbstractSelectableChannel> keys = [:]

                return Stub(AbstractSelector) {
                    register(_,_,_) >> { AbstractSelectableChannel c, int ops, Object att ->
                        events << "register($c, $ops, $att)"
                        SelectionKey key = Stub(SelectionKey) {
                            readyOps() >> { events << "readyOps()"; ops }
                            _ >> { throw new Exception() }
                        }
                        keys[key] = c
                        return key
                    }
                    select() >> {
                        events << "select()"
                        return keys.size()
                    }
                    selectedKeys() >> { keys.keySet() }
                    _ >> { throw new Exception() }
                }
            }
            _ >> { throw new Exception() }
        }

        return Stub(SocketChannel) {
            implConfigureBlocking(_ as Boolean) >> {  boolean state -> events << "implConfigureBlocking($state)" }
            _ >> { throw new Exception() }
        }
    }

    def "example of SocketChannel stub with Selector" () {
        given:
        List events = []

        // Create a stub socket
        SocketChannel channel = makeSocketChannel(events)

        Selector selector = Selector.open()
        channel.configureBlocking(false);
        SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

        expect:
        selector.select() == 1 // our implementation doesn't block
        List keys = selector.selectedKeys().asList()

        keys == [key] // we have the right key
        key.isReadable() // key is readable, etc.

        // Things happened in the right order
        events == [
            "implConfigureBlocking(false)",
            "register(Mock for type 'SocketChannel', 1, null)",
            "select()",
            "readyOps()",
        ]
    }
}