PositionSourceResolverTest.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.engine.target.resolver;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNotSame;
import static org.testng.Assert.assertNull;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import org.mockito.Mockito;
import org.testng.annotations.Test;

import com.opengamma.core.position.Portfolio;
import com.opengamma.core.position.PortfolioNode;
import com.opengamma.core.position.PositionSource;
import com.opengamma.core.position.impl.MockPositionSource;
import com.opengamma.core.position.impl.SimplePortfolio;
import com.opengamma.core.position.impl.SimplePortfolioNode;
import com.opengamma.core.position.impl.SimplePosition;
import com.opengamma.core.position.impl.SimpleTrade;
import com.opengamma.core.security.impl.SimpleSecurityLink;
import com.opengamma.engine.target.logger.ResolutionLogger;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.id.ObjectId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
import com.opengamma.util.test.TestGroup;

/**
 * Test the {@link PositionSource} based resolvers
 */
@Test(groups = TestGroup.UNIT)
public class PositionSourceResolverTest {

  private final SimplePortfolioNode NODE = new SimplePortfolioNode("Root");
  private final SimplePosition POSITION = new SimplePosition();
  private final SimpleTrade TRADE = new SimpleTrade();
  private final SimplePortfolio PORTFOLIO = new SimplePortfolio("Test");
  private final MockPositionSource POSITION_SOURCE = new MockPositionSource();
  private final UniqueId BAD_ID = UniqueId.of("Missing", "0");

  public PositionSourceResolverTest() {
    POSITION.setQuantity(BigDecimal.ONE);
    POSITION.setSecurityLink(new SimpleSecurityLink(ExternalId.of("Security", "Foo")));
    TRADE.setSecurityLink(new SimpleSecurityLink(ExternalId.of("Security", "Foo")));
    TRADE.setQuantity(BigDecimal.ONE);
    POSITION.addTrade(TRADE);
    NODE.addPosition(POSITION);
    PORTFOLIO.setRootNode(NODE);
    PORTFOLIO.setUniqueId(UniqueId.of("Portfolio", "0"));
    POSITION_SOURCE.addPortfolio(PORTFOLIO);
  }

  private PositionSourceResolver resolver() {
    return new PositionSourceResolver(POSITION_SOURCE);
  }

  public void trade_object_resolved() {
    assertEquals(resolver().trade().resolveObject(TRADE.getUniqueId(), VersionCorrection.LATEST), TRADE);
  }

  public void trade_object_unresolved() {
    assertEquals(resolver().trade().resolveObject(BAD_ID, VersionCorrection.LATEST), null);
  }

  public void trade_deep() {
    assertNull(resolver().trade().deepResolver());
  }

  public void position_object_resolved() {
    assertEquals(resolver().position().resolveObject(POSITION.getUniqueId(), VersionCorrection.LATEST), POSITION);
  }

  public void position_object_unresolved() {
    assertEquals(resolver().position().resolveObject(BAD_ID, VersionCorrection.LATEST), null);
  }

  public void position_identifier_single() {
    assertEquals(resolver().position().resolveExternalId(ExternalIdBundle.EMPTY, VersionCorrection.LATEST), null);
  }

  public void position_identifier_multiple() {
    assertEquals(resolver().position().resolveExternalIds(Collections.singleton(ExternalIdBundle.EMPTY), VersionCorrection.LATEST), Collections.emptyMap());
  }

  public void position_uniqueid_resolved() {
    assertEquals(resolver().position().resolveObjectId(POSITION.getUniqueId().getObjectId(), VersionCorrection.LATEST), POSITION.getUniqueId());
  }

  public void position_uniqueid_unresolved() {
    assertEquals(resolver().position().resolveObjectId(BAD_ID.getObjectId(), VersionCorrection.LATEST), null);
  }

  public void position_uniqueid_multiple() {
    final Set<ObjectId> request = new HashSet<ObjectId>();
    request.add(POSITION.getUniqueId().getObjectId());
    request.add(BAD_ID.getObjectId());
    assertEquals(resolver().position().resolveObjectIds(request, VersionCorrection.LATEST), Collections.singletonMap(POSITION.getUniqueId().getObjectId(), POSITION.getUniqueId()));
  }

  public void position_deep() {
    assertNull(resolver().position().deepResolver());
  }

  public void portfolio_object_resolved() {
    assertEquals(resolver().portfolio().resolveObject(PORTFOLIO.getUniqueId(), VersionCorrection.LATEST), PORTFOLIO);
  }

  public void portfolio_object_unresolved() {
    assertEquals(resolver().portfolio().resolveObject(BAD_ID, VersionCorrection.LATEST), null);
  }

  public void portfolio_identifier_single() {
    assertEquals(resolver().portfolio().resolveExternalId(ExternalIdBundle.EMPTY, VersionCorrection.LATEST), null);
  }

  public void portfolio_identifier_multiple() {
    assertEquals(resolver().portfolio().resolveExternalIds(Collections.singleton(ExternalIdBundle.EMPTY), VersionCorrection.LATEST), Collections.emptyMap());
  }

  public void portfolio_uniqueid_resolved() {
    assertEquals(resolver().portfolio().resolveObjectId(PORTFOLIO.getUniqueId().getObjectId(), VersionCorrection.LATEST), PORTFOLIO.getUniqueId());
  }

  public void portfolio_uniqueid_unresolved() {
    assertEquals(resolver().portfolio().resolveObjectId(BAD_ID.getObjectId(), VersionCorrection.LATEST), null);
  }

  public void portfolio_uniqueid_multiple() {
    final Set<ObjectId> request = new HashSet<ObjectId>();
    request.add(PORTFOLIO.getUniqueId().getObjectId());
    request.add(BAD_ID.getObjectId());
    assertEquals(resolver().portfolio().resolveObjectIds(request, VersionCorrection.LATEST), Collections.singletonMap(PORTFOLIO.getUniqueId().getObjectId(), PORTFOLIO.getUniqueId()));
  }

  public void portfolio_deep() {
    final DeepResolver deep = resolver().portfolio().deepResolver();
    assertNotNull(deep);
    ResolutionLogger logger = Mockito.mock(ResolutionLogger.class);
    final Portfolio portfolio = (Portfolio) deep.withLogger(PORTFOLIO, logger);
    assertNotNull(portfolio);
    assertNotSame(portfolio, PORTFOLIO);
    assertEquals(portfolio.getUniqueId(), PORTFOLIO.getUniqueId());
  }

  public void node_object_resolved() {
    assertEquals(resolver().portfolioNode().resolveObject(NODE.getUniqueId(), VersionCorrection.LATEST), NODE);
  }

  public void node_object_unresolved() {
    assertEquals(resolver().portfolioNode().resolveObject(BAD_ID, VersionCorrection.LATEST), null);
  }

  public void node_deep() {
    final DeepResolver deep = resolver().portfolioNode().deepResolver();
    assertNotNull(deep);
    ResolutionLogger logger = Mockito.mock(ResolutionLogger.class);
    final PortfolioNode node = (PortfolioNode) deep.withLogger(NODE, logger);
    assertNotNull(node);
    assertNotSame(node, NODE);
    assertEquals(node.getUniqueId(), NODE.getUniqueId());
  }

}