test_cache.py

from twisted.internet import reactor
from twisted.internet.address import IPv4Address
from twisted.protocols.memcache import MemCacheProtocol
from twisted.trial.unittest import TestCase
from txconnpool.pool import PooledClientFactory, Pool

CACHE_POOL = None

class _PooledMemCacheProtocol(MemCacheProtocol):
    factory = None

    def connectionMade(self):
        MemCacheProtocol.connectionMade(self)

        self.factory.connectionPool.clientFree(self)

        if self.factory.deferred is not None:
            self.factory.deferred.callback(self)
            self.factory.deferred = None


class _MemCacheClientFactory(PooledClientFactory):
    protocol = _PooledMemCacheProtocol


class MemCachePool(Pool):
    clientFactory = _MemCacheClientFactory

    def get(self, *args, **kwargs):
        return self.perform_request_with_timeout('get', *args, **kwargs)

    def set(self, *args, **kwargs):
        return self.perform_request_with_timeout('set', *args, **kwargs)

    def perform_request_with_timeout(self, request, *args, **kwargs):
        def _timeout_conn_check():
            d.cancel()

        dc = reactor.callLater(1, _timeout_conn_check)

        def _cancel_timeout(result):
            if dc.active():
                dc.cancel()

            return result

        d = self.performRequest(request, *args, **kwargs)
        d.addBoth(_cancel_timeout)
        return d

def get_cache_pool():
    global CACHE_POOL
    if not CACHE_POOL:
        CACHE_POOL = MemCachePool(IPv4Address('TCP', '127.0.0.1', 11211), maxClients=1)

    return CACHE_POOL

def make_a_request():
    d = get_cache_pool().get('some_key')
    d.addCallback(lambda x: x)
    return d

class SomeTest(TestCase):
    def tearDown(self):
        return get_cache_pool()._shutdownCallback()

    def test_1(self):
        d = make_a_request()
        d.addCallback(self.assertTrue)
        return d

    def test_2(self):
        d = make_a_request()
        d.addCallback(self.assertTrue)
        return d

The first test passes, the second one fails.