@Test
public void useExplicitComponentImplementations() throws Exception {
settings.setString(SLF4JLogFactory.SETTING_EVENT_CATEGORY, "Events");
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
MessageStoreFactory messageStoreFactory = Mockito.mock(MessageStoreFactory.class);
LogFactory logFactory = Mockito.mock(LogFactory.class);
MessageFactory messageFactory = Mockito.mock(MessageFactory.class);
quickfixjEngine =
new QuickfixjEngine(
"quickfix:test",
settingsFile.getName(),
messageStoreFactory,
logFactory,
messageFactory);
assertThat(quickfixjEngine.getMessageStoreFactory(), is(messageStoreFactory));
assertThat(quickfixjEngine.getLogFactory(), is(logFactory));
assertThat(quickfixjEngine.getMessageFactory(), is(messageFactory));
}
private void assertDefaultConfiguration(QuickfixjEngine quickfixjEngine) throws Exception {
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(MemoryStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(ScreenLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> names = mbeanServer.queryNames(new ObjectName("org.quickfixj:*"), null);
assertTrue("QFJ Connector/Initiator mbeans should not have been registered", names.isEmpty());
}
@Test
public void defaultAcceptor() throws Exception {
settings.setString(
sessionID, SessionFactory.SETTING_CONNECTION_TYPE, SessionFactory.ACCEPTOR_CONNECTION_TYPE);
settings.setLong(sessionID, Acceptor.SETTING_SOCKET_ACCEPT_PORT, 1234);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), nullValue());
assertThat(quickfixjEngine.getAcceptor(), instanceOf(SocketAcceptor.class));
assertDefaultConfiguration(quickfixjEngine);
}
@After
public void tearDown() throws Exception {
Thread.currentThread().setContextClassLoader(contextClassLoader);
if (quickfixjEngine != null) {
quickfixjEngine.stop();
}
}
private void doApplicationMessageEventsTest(
SessionID acceptorSessionID, SessionID initiatorSessionID, QuickfixjEngine quickfixjEngine)
throws SessionNotFound, InterruptedException, FieldNotFound {
final List<EventRecord> events = new ArrayList<EventRecord>();
final CountDownLatch messageLatch = new CountDownLatch(1);
QuickfixjEventListener messageListener =
new QuickfixjEventListener() {
@Override
public synchronized void onEvent(
QuickfixjEventCategory eventCategory, SessionID sessionID, Message message) {
EventRecord event = new EventRecord(eventCategory, sessionID, message);
events.add(event);
if (eventCategory == QuickfixjEventCategory.AppMessageReceived) {
messageLatch.countDown();
}
}
};
quickfixjEngine.addEventListener(messageListener);
Email email = TestSupport.createEmailMessage("Test");
Session.sendToTarget(email, initiatorSessionID);
assertTrue("Application message not received", messageLatch.await(5000, TimeUnit.MILLISECONDS));
quickfixjEngine.removeEventListener(messageListener);
assertThat(events.size(), is(2));
EventRecord sendEvent =
new EventRecord(QuickfixjEventCategory.AppMessageSent, initiatorSessionID, new Message());
assertTrue(events.contains(sendEvent));
int sendEventIndex = events.indexOf(sendEvent);
assertThat(
events.get(sendEventIndex).message.getHeader().getString(MsgType.FIELD), is(MsgType.EMAIL));
EventRecord receiveEvent =
new EventRecord(
QuickfixjEventCategory.AppMessageReceived, acceptorSessionID, new Message());
assertTrue(events.contains(receiveEvent));
int receiveEventIndex = events.indexOf(receiveEvent);
assertThat(
events.get(receiveEventIndex).message.getHeader().getString(MsgType.FIELD),
is(MsgType.EMAIL));
}
@Test
public void inferSlf4jLog() throws Exception {
settings.setString(SLF4JLogFactory.SETTING_EVENT_CATEGORY, "Events");
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(MemoryStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(SLF4JLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
}
@Test
public void inferFileLog() throws Exception {
settings.setString(FileLogFactory.SETTING_FILE_LOG_PATH, tempdir.toString());
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(MemoryStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(FileLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
}
@Test
public void inferSleepycatStore() throws Exception {
settings.setString(SleepycatStoreFactory.SETTING_SLEEPYCAT_DATABASE_DIR, tempdir.toString());
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(SleepycatStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(ScreenLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
}
@Test
public void threadPerSessionInitiator() throws Exception {
settings.setString(
QuickfixjEngine.SETTING_THREAD_MODEL,
QuickfixjEngine.ThreadModel.ThreadPerSession.toString());
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), instanceOf(ThreadedSocketInitiator.class));
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertDefaultConfiguration(quickfixjEngine);
}
@Test
public void inferJdbcStoreWithInferredLog() throws Exception {
settings.setString(JdbcSetting.SETTING_JDBC_DRIVER, "driver");
settings.setBool(ScreenLogFactory.SETTING_LOG_EVENTS, true);
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(JdbcStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(ScreenLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
}
@Test
public void inferJdbcStoreViaJNDI() throws Exception {
// If there is a setting of the LOG_EVENT_TABLE, we should create a jdbcLogFactory for it
settings.setString(JdbcSetting.SETTING_JDBC_DS_NAME, "ds_name");
settings.setString(JdbcSetting.SETTING_LOG_EVENT_TABLE, "table");
settings.setString(
sessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), nullValue());
assertThat(quickfixjEngine.getMessageStoreFactory(), instanceOf(JdbcStoreFactory.class));
assertThat(quickfixjEngine.getLogFactory(), instanceOf(JdbcLogFactory.class));
assertThat(quickfixjEngine.getMessageFactory(), instanceOf(DefaultMessageFactory.class));
}
@Test
public void minimalInitiatorAndAcceptor() throws Exception {
settings.setString(
sessionID, SessionFactory.SETTING_CONNECTION_TYPE, SessionFactory.ACCEPTOR_CONNECTION_TYPE);
settings.setLong(sessionID, Acceptor.SETTING_SOCKET_ACCEPT_PORT, 1234);
SessionID initiatorSessionID = new SessionID(FixVersions.BEGINSTRING_FIX44, "FARGLE", "BARGLE");
settings.setString(
initiatorSessionID,
SessionFactory.SETTING_CONNECTION_TYPE,
SessionFactory.INITIATOR_CONNECTION_TYPE);
TestSupport.setSessionID(settings, initiatorSessionID);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
assertThat(quickfixjEngine.getInitiator(), notNullValue());
assertThat(quickfixjEngine.getAcceptor(), notNullValue());
assertDefaultConfiguration(quickfixjEngine);
}
private void doLogoffEventsTest(
SessionID acceptorSessionID, SessionID initiatorSessionID, QuickfixjEngine quickfixjEngine)
throws Exception {
final List<EventRecord> events = new ArrayList<EventRecord>();
final CountDownLatch logoffLatch = new CountDownLatch(2);
QuickfixjEventListener logoffListener =
new QuickfixjEventListener() {
@Override
public synchronized void onEvent(
QuickfixjEventCategory eventCategory, SessionID sessionID, Message message) {
EventRecord event = new EventRecord(eventCategory, sessionID, message);
events.add(event);
if (eventCategory == QuickfixjEventCategory.SessionLogoff) {
logoffLatch.countDown();
}
}
};
quickfixjEngine.addEventListener(logoffListener);
quickfixjEngine.stop();
assertTrue("Logoffs not received", logoffLatch.await(5000, TimeUnit.MILLISECONDS));
quickfixjEngine.removeEventListener(logoffListener);
assertThat(events.size(), is(2));
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionLogoff, acceptorSessionID, null)));
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionLogoff, initiatorSessionID, null)));
}
@Test
public void enableJmxForAcceptor() throws Exception {
settings.setBool(QuickfixjEngine.SETTING_USE_JMX, true);
settings.setString(
sessionID, SessionFactory.SETTING_CONNECTION_TYPE, SessionFactory.ACCEPTOR_CONNECTION_TYPE);
settings.setLong(sessionID, Acceptor.SETTING_SOCKET_ACCEPT_PORT, 1234);
writeSettings();
quickfixjEngine = new QuickfixjEngine("quickfix:test", settingsFile.getName());
quickfixjEngine.start();
MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
Set<ObjectName> n =
mbeanServer.queryNames(
new ObjectName("org.quickfixj:type=Connector,role=Acceptor,*"), null);
assertFalse("QFJ mbean not registered", n.isEmpty());
}
private void doLogonEventsTest(
SessionID acceptorSessionID, SessionID initiatorSessionID, QuickfixjEngine quickfixjEngine)
throws Exception {
final List<EventRecord> events = new ArrayList<EventRecord>();
final CountDownLatch logonLatch = new CountDownLatch(2);
QuickfixjEventListener logonListener =
new QuickfixjEventListener() {
@Override
public synchronized void onEvent(
QuickfixjEventCategory eventCategory, SessionID sessionID, Message message) {
events.add(new EventRecord(eventCategory, sessionID, message));
if (eventCategory == QuickfixjEventCategory.SessionLogon) {
logonLatch.countDown();
}
}
};
quickfixjEngine.addEventListener(logonListener);
quickfixjEngine.start();
assertTrue("Logons not completed", logonLatch.await(5000, TimeUnit.MILLISECONDS));
quickfixjEngine.removeEventListener(logonListener);
assertThat(events.size(), is(8));
// The session events will arrive out of order as the event callbacks happen in the context of
// different threads so that the asserts
// below must cater for that, that's do not assert on the order of the arrived events but just
// do assert on their existence. for this
// to work we have've defined a relaxed comparison about the messages being sent, see the
// EventRecord.equals() method
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionCreated, acceptorSessionID, null)));
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionCreated, initiatorSessionID, null)));
assertTrue(
events.contains(
new EventRecord(
QuickfixjEventCategory.AdminMessageSent, initiatorSessionID, new Message())));
assertTrue(
events.contains(
new EventRecord(
QuickfixjEventCategory.AdminMessageReceived, acceptorSessionID, new Message())));
assertTrue(
events.contains(
new EventRecord(
QuickfixjEventCategory.AdminMessageSent, acceptorSessionID, new Message())));
assertTrue(
events.contains(
new EventRecord(
QuickfixjEventCategory.AdminMessageReceived, initiatorSessionID, new Message())));
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionLogon, initiatorSessionID, null)));
assertTrue(
events.contains(
new EventRecord(QuickfixjEventCategory.SessionLogon, acceptorSessionID, null)));
}
