public void testDefaults() throws Exception {
ConnectionFactory f = b.build();
assertEquals(DefaultConnectionFactory.DEFAULT_OPERATION_TIMEOUT, f.getOperationTimeout());
assertEquals(DefaultConnectionFactory.DEFAULT_READ_BUFFER_SIZE, f.getReadBufSize());
assertSame(DefaultConnectionFactory.DEFAULT_HASH, f.getHashAlg());
assertTrue(f.getDefaultTranscoder() instanceof SerializingTranscoder);
assertSame(DefaultConnectionFactory.DEFAULT_FAILURE_MODE, f.getFailureMode());
assertEquals(0, f.getInitialObservers().size());
assertTrue(f.getOperationFactory() instanceof AsciiOperationFactory);
BlockingQueue<Operation> opQueue = f.createOperationQueue();
assertTrue(opQueue instanceof ArrayBlockingQueue<?>);
assertEquals(DefaultConnectionFactory.DEFAULT_OP_QUEUE_LEN, opQueue.remainingCapacity());
BlockingQueue<Operation> readOpQueue = f.createReadOperationQueue();
assertTrue(readOpQueue instanceof LinkedBlockingQueue<?>);
BlockingQueue<Operation> writeOpQueue = f.createWriteOperationQueue();
assertTrue(writeOpQueue instanceof LinkedBlockingQueue<?>);
MemcachedNode n = (MemcachedNode) mock(MemcachedNode.class).proxy();
assertTrue(f.createLocator(Collections.singletonList(n)) instanceof ArrayModNodeLocator);
final MemcachedNode testNode =
f.createMemcachedNode(
InetSocketAddress.createUnresolved("localhost", TestConfig.PORT_NUMBER), 1);
try {
assertTrue(testNode instanceof AsciiMemcachedNodeImpl);
} finally {
testNode.getChannel().close();
}
assertFalse(f.isDaemon());
assertFalse(f.shouldOptimize());
assertFalse(f.useNagleAlgorithm());
assertEquals(
f.getOpQueueMaxBlockTime(), DefaultConnectionFactory.DEFAULT_OP_QUEUE_MAX_BLOCK_TIME);
}
public void testModifications() throws Exception {
ConnectionObserver testObserver =
new ConnectionObserver() {
public void connectionLost(SocketAddress sa) {
// none
}
public void connectionEstablished(SocketAddress sa, int reconnectCount) {
// none
}
};
BlockingQueue<Operation> oQueue = new LinkedBlockingQueue<Operation>();
BlockingQueue<Operation> rQueue = new LinkedBlockingQueue<Operation>();
BlockingQueue<Operation> wQueue = new LinkedBlockingQueue<Operation>();
OperationQueueFactory opQueueFactory = new DirectFactory(oQueue);
OperationQueueFactory rQueueFactory = new DirectFactory(rQueue);
OperationQueueFactory wQueueFactory = new DirectFactory(wQueue);
AuthDescriptor anAuthDescriptor =
new AuthDescriptor(
new String[] {"PLAIN"}, new PlainCallbackHandler("username", "password"));
ConnectionFactory f =
b.setDaemon(true)
.setShouldOptimize(false)
.setFailureMode(FailureMode.Redistribute)
.setHashAlg(DefaultHashAlgorithm.KETAMA_HASH)
.setInitialObservers(Collections.singleton(testObserver))
.setOpFact(new BinaryOperationFactory())
.setOpTimeout(4225)
.setOpQueueFactory(opQueueFactory)
.setReadOpQueueFactory(rQueueFactory)
.setWriteOpQueueFactory(wQueueFactory)
.setReadBufferSize(19)
.setTranscoder(new WhalinTranscoder())
.setUseNagleAlgorithm(true)
.setLocatorType(Locator.CONSISTENT)
.setOpQueueMaxBlockTime(19)
.setAuthDescriptor(anAuthDescriptor)
.build();
assertEquals(4225, f.getOperationTimeout());
assertEquals(19, f.getReadBufSize());
assertSame(DefaultHashAlgorithm.KETAMA_HASH, f.getHashAlg());
assertTrue(f.getDefaultTranscoder() instanceof WhalinTranscoder);
assertSame(FailureMode.Redistribute, f.getFailureMode());
assertEquals(1, f.getInitialObservers().size());
assertSame(testObserver, f.getInitialObservers().iterator().next());
assertTrue(f.getOperationFactory() instanceof BinaryOperationFactory);
assertSame(oQueue, f.createOperationQueue());
assertSame(rQueue, f.createReadOperationQueue());
assertSame(wQueue, f.createWriteOperationQueue());
assertTrue(f.isDaemon());
assertFalse(f.shouldOptimize());
assertTrue(f.useNagleAlgorithm());
assertEquals(f.getOpQueueMaxBlockTime(), 19);
assertSame(anAuthDescriptor, f.getAuthDescriptor());
MemcachedNode n =
new MockMemcachedNode(
InetSocketAddress.createUnresolved("localhost", TestConfig.PORT_NUMBER));
assertTrue(f.createLocator(Collections.singletonList(n)) instanceof KetamaNodeLocator);
final MemcachedNode testNode =
f.createMemcachedNode(
InetSocketAddress.createUnresolved("localhost", TestConfig.PORT_NUMBER), 1);
try {
assertTrue(testNode instanceof BinaryMemcachedNodeImpl);
} finally {
testNode.getChannel().close();
}
}
