@Test
public void test_search_userIds() {
UserSearchRequest request = new UserSearchRequest();
request.addObjectId(ObjectId.of("DbUsr", "101"));
request.addObjectId(ObjectId.of("DbUsr", "201"));
request.addObjectId(ObjectId.of("DbUsr", "9999"));
UserSearchResult test = _usrMaster.search(request);
assertEquals(2, test.getDocuments().size());
assert101(test.getDocuments().get(0));
assert202(test.getDocuments().get(1));
}
public void test() {
ManageableTrade obj = new ManageableTrade();
obj.setUniqueId(UniqueId.of("U", "1"));
obj.setQuantity(BigDecimal.ONE);
obj.setSecurityLink(new ManageableSecurityLink(ExternalId.of("A", "B")));
obj.getSecurityLink().setObjectId(ObjectId.of("O", "1"));
obj.setTradeDate(LocalDate.of(2011, 6, 1));
obj.setCounterpartyExternalId(ExternalId.of("C", "D"));
testFudgeMessage(obj);
}
@Test
public void test_searchPositionHistoric_documentCountWhenMultipleSecuritiesAndMultipleTrades() {
ObjectId oid = ObjectId.of("DbPos", "123");
PositionHistoryRequest request = new PositionHistoryRequest(oid);
PositionHistoryResult test = _posMaster.history(request);
assertEquals(1, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert123(test.getDocuments().get(0));
}
// -------------------------------------------------------------------------
@Test
public void test_history_documents() {
ObjectId oid = ObjectId.of("DbSec", "201");
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(2, test.getDocuments().size());
assert202(test.getDocuments().get(0));
assert201(test.getDocuments().get(1));
}
// -------------------------------------------------------------------------
@Test
public void test_searchPositionHistoric_documents() {
ObjectId oid = ObjectId.of("DbPos", "221");
PositionHistoryRequest request = new PositionHistoryRequest(oid);
PositionHistoryResult test = _posMaster.history(request);
assertEquals(2, test.getDocuments().size());
assert222(test.getDocuments().get(0));
assert221(test.getDocuments().get(1));
}
// -------------------------------------------------------------------------
@Test
public void test_searchPositionHistoric_versionsTo_preFirst() {
ObjectId oid = ObjectId.of("DbPos", "221");
PositionHistoryRequest request = new PositionHistoryRequest(oid);
request.setVersionsToInstant(_version1Instant.minusSeconds(5));
PositionHistoryResult test = _posMaster.history(request);
assertEquals(0, test.getPaging().getTotalItems());
assertEquals(0, test.getDocuments().size());
}
// -------------------------------------------------------------------------
@Test
public void test_history_versionsTo_preFirst() {
ObjectId oid = ObjectId.of("DbSec", "201");
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
request.setVersionsToInstant(_version1Instant.minusSeconds(5));
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(0, test.getPaging().getTotalItems());
assertEquals(0, test.getDocuments().size());
}
@Test
public void test_history_documentCountWhenMultipleSecuritys() {
ObjectId oid = ObjectId.of("DbSec", "102");
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(1, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert102(test.getDocuments().get(0));
}
@Test
public void test_searchPositionHistoric_versionsFrom_postSecond() {
ObjectId oid = ObjectId.of("DbPos", "221");
PositionHistoryRequest request = new PositionHistoryRequest(oid);
request.setVersionsFromInstant(_version2Instant.plusSeconds(5));
PositionHistoryResult test = _posMaster.history(request);
assertEquals(1, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert222(test.getDocuments().get(0));
}
@Test
public void test_history_versionsFrom_postSecond() {
ObjectId oid = ObjectId.of("DbSec", "201");
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
request.setVersionsFromInstant(_version2Instant.plusSeconds(5));
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(1, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert202(test.getDocuments().get(0));
}
/**
* Parses an {@code ObjectId} from a formatted scheme and value.
*
* <p>This parses the identifier from the form produced by {@code toString()} which is {@code
* <SCHEME>~<VALUE>}.
*
* @param str the object identifier to parse, not null
* @return the object identifier, not null
* @throws IllegalArgumentException if the identifier cannot be parsed
*/
@FromString
public static ObjectId parse(String str) {
ArgumentChecker.notEmpty(str, "str");
if (str.contains("~") == false) {
str = StringUtils.replace(str, "::", "~"); // leniently parse old data
}
String[] split = StringUtils.splitByWholeSeparatorPreserveAllTokens(str, "~");
switch (split.length) {
case 2:
return ObjectId.of(split[0], split[1]);
}
throw new IllegalArgumentException("Invalid identifier format: " + str);
}
// -------------------------------------------------------------------------
@Test
public void test_history_noInstants() {
ObjectId oid = ObjectId.of("DbSec", "201");
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(PagingRequest.ALL, test.getPaging().getRequest());
assertEquals(2, test.getPaging().getTotalItems());
assertEquals(2, test.getDocuments().size());
assert202(test.getDocuments().get(0));
assert201(test.getDocuments().get(1));
}
// -------------------------------------------------------------------------
@Test
public void test_history_noInstants_pageOne() {
ObjectId oid = ObjectId.of("DbSec", "201");
PagingRequest pr = PagingRequest.ofPage(1, 1);
SecurityHistoryRequest request = new SecurityHistoryRequest(oid);
request.setPagingRequest(pr);
SecurityHistoryResult test = _secMaster.history(request);
assertEquals(pr, test.getPaging().getRequest());
assertEquals(2, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert202(test.getDocuments().get(0));
}
// -------------------------------------------------------------------------
@Test
public void test_searchPositionHistoric_noInstants_pageOne() {
ObjectId oid = ObjectId.of("DbPos", "221");
PositionHistoryRequest request = new PositionHistoryRequest(oid);
request.setPagingRequest(PagingRequest.ofPage(1, 1));
PositionHistoryResult test = _posMaster.history(request);
assertEquals(1, test.getPaging().getFirstItemOneBased());
assertEquals(1, test.getPaging().getPagingSize());
assertEquals(2, test.getPaging().getTotalItems());
assertEquals(1, test.getDocuments().size());
assert222(test.getDocuments().get(0));
}
@SuppressWarnings("deprecation")
public void testTrade_withPremium() {
SimpleTrade trade = new SimpleTrade();
trade.setUniqueId(UniqueId.of("A", "B"));
trade.setQuantity(BigDecimal.valueOf(12.34d));
trade.setSecurityLink(new SimpleSecurityLink(ObjectId.of("E", "F")));
trade.setCounterparty(new SimpleCounterparty(ExternalId.of("G", "H")));
trade.setTradeDate(LocalDate.of(2011, 1, 5));
trade.setTradeTime(OffsetTime.parse("14:30+02:00"));
// set premium
trade.setPremium(100.00);
trade.setPremiumCurrency(Currency.USD);
trade.setPremiumDate(LocalDate.of(2011, 1, 6));
trade.setPremiumTime(OffsetTime.parse("15:30+02:00"));
assertEncodeDecodeCycle(Trade.class, trade);
}
/** Test. */
public class DataConfigSourceResourceTest {
private static final ObjectId OID = ObjectId.of("Test", "A");
private static final UniqueId UID = OID.atVersion("B");
private static final VersionCorrection VC =
VersionCorrection.LATEST.withLatestFixed(Instant.now());
private static final String NAME = "name";
private ConfigSource _underlying;
private UriInfo _uriInfo;
private DataConfigSourceResource _resource;
@BeforeMethod
public void setUp() {
_underlying = mock(ConfigSource.class);
_uriInfo = mock(UriInfo.class);
when(_uriInfo.getBaseUri()).thenReturn(URI.create("testhost"));
_resource = new DataConfigSourceResource(_underlying);
}
// -------------------------------------------------------------------------
@Test
public void testGetConfigByUid() {
final SimpleExchange target = new SimpleExchange();
target.setName("Test");
when(_underlying.getConfig(eq(SimpleExchange.class), eq(UID))).thenReturn(target);
Response test =
_resource.get(OID.toString(), SimpleExchange.class.getName(), UID.getVersion(), "", "");
assertEquals(Status.OK.getStatusCode(), test.getStatus());
assertSame(target, test.getEntity());
}
@Test
public void testGetConfigByOid() {
final SimpleExchange target = new SimpleExchange();
target.setName("Test");
when(_underlying.getConfig(eq(SimpleExchange.class), eq(OID), eq(VC))).thenReturn(target);
Response test =
_resource.get(
OID.toString(),
SimpleExchange.class.getName(),
null,
VC.getVersionAsOfString(),
VC.getCorrectedToString());
assertEquals(Status.OK.getStatusCode(), test.getStatus());
assertSame(target, test.getEntity());
}
@SuppressWarnings({"rawtypes", "unchecked"})
@Test
public void testSearch() {
final SimpleExchange target = new SimpleExchange();
target.setName("Test");
Collection targetColl = ImmutableList.of(target);
when(_underlying.getConfigs(eq(SimpleExchange.class), eq(NAME), eq(VC))).thenReturn(targetColl);
Response test =
_resource.search(
SimpleExchange.class.getName(),
VC.getVersionAsOfString(),
VC.getCorrectedToString(),
NAME);
assertEquals(Status.OK.getStatusCode(), test.getStatus());
assertEquals(FudgeListWrapper.of(targetColl), test.getEntity());
}
}
/**
* Returns a copy of this identifier with the specified scheme.
*
* @param scheme the new scheme of the identifier, not empty, not null
* @return an {@link ObjectId} based on this identifier with the specified scheme, not null
*/
public ObjectId withScheme(final String scheme) {
return ObjectId.of(scheme, _value);
}
/**
* Returns a copy of this identifier with the specified value.
*
* @param value the new value of the identifier, not empty, not null
* @return an {@link ObjectId} based on this identifier with the specified value, not null
*/
public ObjectId withValue(final String value) {
return ObjectId.of(_scheme, value);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_search_userIds_badSchemeValidOid() {
UserSearchRequest request = new UserSearchRequest();
request.addObjectId(ObjectId.of("Rubbish", "120"));
_usrMaster.search(request);
}
public void testGetSecurity_byObjectId() {
final SecuritySource underlying = Mockito.mock(SecuritySource.class);
final SecuritySource coalescing = new CoalescingSecuritySource(underlying);
coalescing.get(ObjectId.of("Test", "Test"), VersionCorrection.LATEST);
Mockito.verify(underlying).get(ObjectId.of("Test", "Test"), VersionCorrection.LATEST);
}
/** Test {@link MasterExchangeSource}. */
@Test(groups = TestGroup.UNIT)
public class MasterExchangeSourceTest {
private static final ObjectId OID = ObjectId.of("A", "B");
private static final UniqueId UID = UniqueId.of("A", "B", "V");
private static final ExternalId ID = ExternalId.of("C", "D");
private static final ExternalIdBundle BUNDLE = ExternalIdBundle.of(ID);
private static final Instant NOW = Instant.now();
private static final VersionCorrection VC =
VersionCorrection.of(NOW.minusSeconds(2), NOW.minusSeconds(1));
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_1arg_nullMaster() throws Exception {
new MasterExchangeSource(null);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_constructor_2arg_nullMaster() throws Exception {
new MasterExchangeSource(null, null);
}
// -------------------------------------------------------------------------
public void test_getExchange_UniqueId_noOverride_found() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeDocument doc = new ExchangeDocument(example());
when(mock.get(UID)).thenReturn(doc);
MasterExchangeSource test = new MasterExchangeSource(mock);
Exchange testResult = test.get(UID);
verify(mock, times(1)).get(UID);
assertEquals(example(), testResult);
}
public void test_getExchange_UniqueId_found() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeDocument doc = new ExchangeDocument(example());
when(mock.get(OID, VC)).thenReturn(doc);
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
Exchange testResult = test.get(UID);
verify(mock, times(1)).get(OID, VC);
assertEquals(example(), testResult);
}
@Test(expectedExceptions = DataNotFoundException.class)
public void test_getExchange_UniqueId_notFound() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
when(mock.get(OID, VC)).thenThrow(new DataNotFoundException(""));
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
try {
test.get(UID);
} finally {
verify(mock, times(1)).get(OID, VC);
}
}
// -------------------------------------------------------------------------
public void test_getExchange_ObjectId_found() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeDocument doc = new ExchangeDocument(example());
when(mock.get(OID, VC)).thenReturn(doc);
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
Exchange testResult = test.get(OID, VC);
verify(mock, times(1)).get(OID, VC);
assertEquals(example(), testResult);
}
@Test(expectedExceptions = DataNotFoundException.class)
public void test_getExchange_ObjectId_notFound() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
when(mock.get(OID, VC)).thenThrow(new DataNotFoundException(""));
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
try {
test.get(OID, VC);
} finally {
verify(mock, times(1)).get(OID, VC);
}
}
// -------------------------------------------------------------------------
public void test_getSingleExchange_ExternalId_found() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeSearchRequest request = new ExchangeSearchRequest(ID);
request.setPagingRequest(PagingRequest.ONE);
request.setPagingRequest(PagingRequest.ONE);
request.setVersionCorrection(VC);
ExchangeSearchResult result = new ExchangeSearchResult();
result.getDocuments().add(new ExchangeDocument(example()));
when(mock.search(request)).thenReturn(result);
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
Exchange testResult = test.getSingle(ID);
verify(mock, times(1)).search(request);
assertEquals(example(), testResult);
}
public void test_getSingleExchange_ExternalId_notFound() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeSearchRequest request = new ExchangeSearchRequest(ID);
request.setPagingRequest(PagingRequest.ONE);
request.setPagingRequest(PagingRequest.ONE);
request.setVersionCorrection(VC);
ExchangeSearchResult result = new ExchangeSearchResult();
when(mock.search(request)).thenReturn(result);
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
Exchange testResult = test.getSingle(ID);
verify(mock, times(1)).search(request);
assertEquals(null, testResult);
}
// -------------------------------------------------------------------------
public void test_getSingleExchange_ExternalIdBundle_found() throws Exception {
ExchangeMaster mock = mock(ExchangeMaster.class);
ExchangeSearchRequest request = new ExchangeSearchRequest(BUNDLE);
request.setPagingRequest(PagingRequest.ONE);
request.setVersionCorrection(VC);
ExchangeSearchResult result = new ExchangeSearchResult();
result.getDocuments().add(new ExchangeDocument(example()));
when(mock.search(request)).thenReturn(result);
MasterExchangeSource test = new MasterExchangeSource(mock, VC);
Exchange testResult = test.getSingle(BUNDLE);
verify(mock, times(1)).search(request);
assertEquals(example(), testResult);
}
// -------------------------------------------------------------------------
protected ManageableExchange example() {
ManageableExchange exchange = new ManageableExchange();
exchange.setUniqueId(UID);
exchange.setName("NYSE");
exchange.setRegionIdBundle(ExternalIdBundle.of(ExternalSchemes.countryRegionId(Country.US)));
return exchange;
}
}
@Override
public ObjectId getObjectId() {
return ObjectId.of(BatchMaster.BATCH_IDENTIFIER_SCHEME, Long.toString(getId()));
}