ComputationTargetSpecificationTest.java example

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

import static org.testng.Assert.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;

import java.math.BigDecimal;

import org.testng.annotations.Test;
import org.threeten.bp.LocalDate;

import com.opengamma.core.position.Counterparty;
import com.opengamma.core.position.Position;
import com.opengamma.core.position.Trade;
import com.opengamma.core.position.impl.SimpleCounterparty;
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.Security;
import com.opengamma.core.security.impl.SimpleSecurity;
import com.opengamma.engine.target.ComputationTargetReference;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.id.UniqueId;
import com.opengamma.util.money.Currency;
import com.opengamma.util.test.TestGroup;

/**
 * Test ComputationTargetSpecification.
 */
@Test(groups = TestGroup.UNIT)
public class ComputationTargetSpecificationTest {

  private static final UniqueId UID = UniqueId.of("Test", "1");
  private static final UniqueId UID2 = UniqueId.of("Test", "2");
  private static final SimplePortfolioNode NODE = new SimplePortfolioNode(UID, "Name");
  private static final Security SECURITY = new SimpleSecurity(UID, ExternalIdBundle.EMPTY, "", "");
  private static final Position POSITION = new SimplePosition(UID, new BigDecimal(1), SECURITY);
  private static final Trade TRADE = createTrade();

  private static Trade createTrade() {
    final SimpleTrade trade = new SimpleTrade(SECURITY, BigDecimal.ONE, new SimpleCounterparty(ExternalId.of(Counterparty.DEFAULT_SCHEME, "Foo")), LocalDate.now(), null);
    trade.setUniqueId(UID);
    return trade;
  }

  public void test_constructor_Object_Node() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(NODE);
    assertEquals(ComputationTargetType.PORTFOLIO_NODE, test.getType());
    assertEquals(NODE.getUniqueId(), test.getUniqueId());
  }

  public void test_constructor_Object_Position() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(POSITION);
    assertEquals(ComputationTargetType.POSITION, test.getType());
    assertEquals(POSITION.getUniqueId(), test.getUniqueId());
  }

  public void test_constructor_Object_Security() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(SECURITY);
    assertEquals(ComputationTargetType.SECURITY, test.getType());
    assertEquals(SECURITY.getUniqueId(), test.getUniqueId());
  }

  public void test_constructor_Object_Trade() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(TRADE);
    assertEquals(ComputationTargetType.TRADE, test.getType());
    assertEquals(TRADE.getUniqueId(), test.getUniqueId());
  }

  public void test_constructor_Object_Currency() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(Currency.USD);
    assertEquals(ComputationTargetType.CURRENCY, test.getType());
    assertEquals(Currency.USD.getUniqueId(), test.getUniqueId());
  }

  public void test_constructor_Object_UniqueId() {
    ComputationTargetSpecification test = ComputationTargetSpecification.of(UID);
    assertEquals(ComputationTargetType.PRIMITIVE, test.getType());
    assertEquals(UID, test.getUniqueId());
  }

  public void test_constructor_Type_UniqueId_ok() {
    new ComputationTargetSpecification(ComputationTargetType.PORTFOLIO_NODE, UID);
    new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    new ComputationTargetSpecification(ComputationTargetType.SECURITY, UID);
    new ComputationTargetSpecification(ComputationTargetType.NULL, null);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void test_constructor_Type_UniqueId_nullType_validId() {
    new ComputationTargetSpecification(ComputationTargetType.NULL, UniqueId.of("Foo", "Bar"));
  }

  @Test(expectedExceptions = AssertionError.class)
  public void test_constructor_Type_UniqueId_nullType() {
    new ComputationTargetSpecification(null, UID);
  }

  @Test(expectedExceptions=IllegalArgumentException.class)
  public void test_constructor_Type_UniqueId_nullId() {
    new ComputationTargetSpecification(ComputationTargetType.PORTFOLIO_NODE, (UniqueId) null);
  }

  //-------------------------------------------------------------------------
  public void test_getters_PortfolioNode() {
    ComputationTargetSpecification test = new ComputationTargetSpecification(ComputationTargetType.PORTFOLIO_NODE, UID);
    assertEquals(ComputationTargetType.PORTFOLIO_NODE, test.getType());
    assertEquals(UID.getScheme(), test.getUniqueId().getScheme());
    assertEquals(UID.getValue(), test.getUniqueId().getValue());
  }

  //-------------------------------------------------------------------------
  public void test_toSpecification() {
    ComputationTargetSpecification test = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    assertEquals(true, test.toString().contains("POSITION"));
    assertEquals(true, test.toString().contains(UID.toString()));
  }

  //-------------------------------------------------------------------------
  public void test_equals_similar() {
    ComputationTargetSpecification a1 = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    ComputationTargetSpecification a2 = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    
    assertEquals(true, a1.equals(a1));
    assertEquals(true, a1.equals(a2));
    
    assertEquals(true, a2.equals(a1));
    assertEquals(true, a2.equals(a2));
  }

  public void test_equals_different() {
    ComputationTargetSpecification a = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    ComputationTargetSpecification b = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID2);
    ComputationTargetSpecification c = new ComputationTargetSpecification(ComputationTargetType.SECURITY, UID2);
    
    assertEquals(true, a.equals(a));
    assertEquals(false, a.equals(b));
    assertEquals(false, a.equals(c));
    
    assertEquals(false, b.equals(a));
    assertEquals(true, b.equals(b));
    assertEquals(false, b.equals(c));
    
    assertEquals(false, c.equals(a));
    assertEquals(false, c.equals(b));
    assertEquals(true, c.equals(c));
  }

  public void test_equals_other() {
    ComputationTargetSpecification a = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    assertEquals(false, a.equals(null));
    assertEquals(false, a.equals("Rubbish"));
  }

  public void test_hashCode() {
    ComputationTargetSpecification a = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    ComputationTargetSpecification b = new ComputationTargetSpecification(ComputationTargetType.POSITION, UID);
    assertEquals(true, a.equals(b));
  }

  public void test_isCompatible() {
    ComputationTargetSpecification a = new ComputationTargetSpecification(ComputationTargetType.of(SimpleSecurity.class), UID);
    ComputationTargetSpecification b = new ComputationTargetSpecification(ComputationTargetType.SECURITY, UID);
    assertFalse(a.isCompatible(b));
    assertTrue(b.isCompatible(a));
  }

  @Test(expectedExceptions = {IllegalStateException.class })
  public void test_getRequirement() {
    final ComputationTargetReference a = ComputationTargetSpecification.of(SECURITY);
    a.getRequirement();
  }

  public void test_getSpecification() {
    final ComputationTargetReference a = ComputationTargetSpecification.of(SECURITY);
    assertEquals(a.getSpecification(), a);
  }

  public void testContaining_id() {
    final ComputationTargetReference ref = new ComputationTargetSpecification(ComputationTargetType.SECURITY, UniqueId.of("Foo", "Bar"));
    final ComputationTargetReference underlying = ref.containing(ComputationTargetType.SECURITY, ExternalId.of("Foo", "Underlying"));
    assertEquals(underlying.getParent(), ref);
    assertEquals(underlying.getType(), ComputationTargetType.SECURITY.containing(ComputationTargetType.SECURITY));
  }

  public void testContaining_uid() {
    final ComputationTargetReference ref = new ComputationTargetSpecification(ComputationTargetType.SECURITY, UniqueId.of("Foo", "Bar"));
    final ComputationTargetReference underlying = ref.containing(ComputationTargetType.SECURITY, UniqueId.of("Foo", "Underlying"));
    assertEquals(underlying.getParent(), ref);
    assertEquals(underlying.getType(), ComputationTargetType.SECURITY.containing(ComputationTargetType.SECURITY));
  }

}