TargetResolutionLoggerTest.java example

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

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNotSame;
import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.mockito.Mockito;
import org.testng.annotations.Test;
import org.threeten.bp.Instant;

import com.opengamma.core.security.Security;
import com.opengamma.engine.ComputationTarget;
import com.opengamma.engine.ComputationTargetResolver;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.target.ComputationTargetReference;
import com.opengamma.engine.target.ComputationTargetRequirement;
import com.opengamma.engine.target.ComputationTargetSpecificationResolver;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.engine.target.Primitive;
import com.opengamma.engine.target.logger.ResolutionLogger;
import com.opengamma.engine.target.resolver.DeepResolver;
import com.opengamma.engine.target.resolver.ObjectResolver;
import com.opengamma.id.ExternalId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.UniqueIdentifiable;
import com.opengamma.id.VersionCorrection;
import com.opengamma.util.test.TestGroup;

/**
 * Unit test for the {@link TargetResolutionLogger} class.
 */
@Test(groups = TestGroup.UNIT)
public class TargetResolutionLoggerTest {

  @SuppressWarnings("unchecked")
  public void testResolve_shallow() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection resolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetSpecification spec = new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Foo", "Bar"));
    final ComputationTarget target = new ComputationTarget(spec.replaceIdentifier(UniqueId.of("Foo", "Bar", "Cow")), new Primitive(UniqueId.of("Foo", "Bar", "Cow")));
    Mockito.when(underlying.resolve(spec)).thenReturn(target);
    final ObjectResolver shallowResolver = Mockito.mock(ObjectResolver.class);
    Mockito.when(underlying.getResolver(spec)).thenReturn(shallowResolver);
    assertSame(resolver.resolve(spec), target);
  }

  @SuppressWarnings("unchecked")
  public void testResolve_deep() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection resolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetSpecification spec = new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Foo", "Bar"));
    final ComputationTarget target = new ComputationTarget(spec.replaceIdentifier(UniqueId.of("Foo", "Bar", "Cow")), new Primitive(UniqueId.of("Foo", "Bar", "Cow")));
    Mockito.when(underlying.resolve(spec)).thenReturn(target);
    final ObjectResolver deepResolver = Mockito.mock(ObjectResolver.class);
    Mockito.when(deepResolver.deepResolver()).thenReturn(new DeepResolver() {
      @SuppressWarnings("serial")
      @Override
      public UniqueIdentifiable withLogger(final UniqueIdentifiable underlying, final ResolutionLogger logger) {
        assertSame(underlying, target.getValue());
        return new Primitive(UniqueId.of("Foo", "Bar", "Cow")) {
          @Override
          public int hashCode() {
            // Pretend that this is a deep-resolving operation
            logger.log(spec, underlying.getUniqueId());
            return super.hashCode();
          }
        };
      }
    });
    Mockito.when(underlying.getResolver(spec)).thenReturn(deepResolver);
    final ComputationTarget resolvedTarget = resolver.resolve(spec);
    assertNotSame(resolvedTarget, target);
    assertTrue(resolutions.isEmpty());
    resolvedTarget.getValue().hashCode();
    assertFalse(resolutions.isEmpty());
  }

  private Map<ComputationTargetReference, ComputationTargetSpecification> targets() {
    final Map<ComputationTargetReference, ComputationTargetSpecification> map = new HashMap<ComputationTargetReference, ComputationTargetSpecification>();
    map.put(new ComputationTargetRequirement(ComputationTargetType.PRIMITIVE, ExternalId.of("Test", "1")), ComputationTargetSpecification.NULL);
    map.put(new ComputationTargetRequirement(ComputationTargetType.PRIMITIVE, ExternalId.of("Test", "2")), null);
    map.put(new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "3")),
        new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "3", "X")));
    map.put(new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "4", "X")),
        new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "4", "X")));
    map.put(new ComputationTargetRequirement(ComputationTargetType.PRIMITIVE, ExternalId.of("Foo", "Bar")),
        new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Bar", "OLD")));
    return map;
  }

  public void testGetSpecificationResolver_single() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetSpecificationResolver.AtVersionCorrection underlyingResolver = Mockito.mock(ComputationTargetSpecificationResolver.AtVersionCorrection.class);
    Mockito.when(underlying.getSpecificationResolver()).thenReturn(underlyingResolver);
    final ComputationTargetResolver.AtVersionCorrection targetResolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetSpecificationResolver.AtVersionCorrection specificationResolver = targetResolver.getSpecificationResolver();
    assertNotNull(specificationResolver);
    final Map<ComputationTargetReference, ComputationTargetSpecification> targets = targets();
    for (Map.Entry<ComputationTargetReference, ComputationTargetSpecification> target : targets.entrySet()) {
      Mockito.when(underlyingResolver.getTargetSpecification(target.getKey())).thenReturn(target.getValue());
    }
    for (Map.Entry<ComputationTargetReference, ComputationTargetSpecification> target : targets.entrySet()) {
      assertSame(specificationResolver.getTargetSpecification(target.getKey()), target.getValue());
    }
    assertEquals(resolutions.size(), 2);
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "3", "X")));
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "Bar", "OLD")));
    assertEquals(expiredResolutions.size(), 0);
    final ComputationTargetReference ref = new ComputationTargetRequirement(ComputationTargetType.PRIMITIVE, ExternalId.of("Foo", "Bar"));
    final ComputationTargetSpecification spec = new ComputationTargetSpecification(ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Bar", "NEW"));
    Mockito.when(underlyingResolver.getTargetSpecification(ref)).thenReturn(spec);
    assertSame(specificationResolver.getTargetSpecification(ref), spec);
    assertEquals(resolutions.size(), 2);
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "3", "X")));
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "Bar", "NEW")));
    assertEquals(expiredResolutions, Collections.singleton(UniqueId.of("Test", "Bar", "OLD")));
  }

  public void testGetSpecificationResolver_multi() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetSpecificationResolver.AtVersionCorrection underlyingResolver = Mockito.mock(ComputationTargetSpecificationResolver.AtVersionCorrection.class);
    Mockito.when(underlying.getSpecificationResolver()).thenReturn(underlyingResolver);
    final ComputationTargetResolver.AtVersionCorrection targetResolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetSpecificationResolver.AtVersionCorrection specificationResolver = targetResolver.getSpecificationResolver();
    assertNotNull(specificationResolver);
    final Map<ComputationTargetReference, ComputationTargetSpecification> targets = targets();
    final Set<ComputationTargetReference> refs = new HashSet<ComputationTargetReference>(targets.keySet());
    targets.remove(new ComputationTargetRequirement(ComputationTargetType.PRIMITIVE, ExternalId.of("Test", "2")));
    Mockito.when(underlyingResolver.getTargetSpecifications(refs)).thenReturn(targets);
    assertSame(specificationResolver.getTargetSpecifications(refs), targets);
    assertEquals(resolutions.size(), 2);
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "3", "X")));
    assertTrue(resolutions.containsValue(UniqueId.of("Test", "Bar", "OLD")));
    assertEquals(expiredResolutions.size(), 0);
  }

  public void testGetSpecificationResolver_null() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ComputationTargetSpecificationResolver.AtVersionCorrection underlyingResolver = Mockito.mock(ComputationTargetSpecificationResolver.AtVersionCorrection.class);
    Mockito.when(underlying.getSpecificationResolver()).thenReturn(underlyingResolver);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection targetResolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    Mockito.when(underlyingResolver.getTargetSpecification(ComputationTargetSpecification.NULL)).thenReturn(ComputationTargetSpecification.NULL);
    assertSame(targetResolver.getSpecificationResolver().getTargetSpecification(ComputationTargetSpecification.NULL), ComputationTargetSpecification.NULL);
    assertTrue(resolutions.isEmpty());
    assertTrue(expiredResolutions.isEmpty());
  }

  public void testGetSpecificationResolver_complex() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ComputationTargetSpecificationResolver.AtVersionCorrection underlyingResolver = Mockito.mock(ComputationTargetSpecificationResolver.AtVersionCorrection.class);
    Mockito.when(underlying.getSpecificationResolver()).thenReturn(underlyingResolver);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection targetResolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetSpecification spec1 = ComputationTargetSpecification.of(UniqueId.of("Test", "1")).containing(
        ComputationTargetType.multiple(ComputationTargetType.POSITION, ComputationTargetType.SECURITY), UniqueId.of("Test", "2"));
    final ComputationTargetSpecification spec1V = ComputationTargetSpecification.of(UniqueId.of("Test", "1", "V")).containing(ComputationTargetType.POSITION, UniqueId.of("Test", "2", "V"));
    Mockito.when(underlyingResolver.getTargetSpecification(spec1)).thenReturn(spec1V);
    final ComputationTargetSpecification spec2 = new ComputationTargetSpecification(new ComputationTargetSpecification(ComputationTargetType.POSITION_OR_TRADE, UniqueId.of("Test", "4", "V")),
        ComputationTargetType.POSITION.containing(ComputationTargetType.TRADE).or(ComputationTargetType.TRADE.containing(ComputationTargetType.SECURITY)), UniqueId.of("Test", "3"));
    final ComputationTargetSpecification spec2V = new ComputationTargetSpecification(new ComputationTargetSpecification(ComputationTargetType.POSITION_OR_TRADE, UniqueId.of("Test", "4", "V")),
        ComputationTargetType.POSITION.containing(ComputationTargetType.TRADE).or(ComputationTargetType.TRADE.containing(ComputationTargetType.SECURITY)), UniqueId.of("Test", "3", "V"));
    Mockito.when(underlyingResolver.getTargetSpecification(spec2)).thenReturn(spec2V);
    assertSame(targetResolver.getSpecificationResolver().getTargetSpecification(spec1), spec1V);
    assertSame(targetResolver.getSpecificationResolver().getTargetSpecification(spec2), spec2V);
  }

  private interface TestSecurity extends Security {
  }

  public void testSimplifyType() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection resolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final ComputationTargetType type = ComputationTargetType.of(TestSecurity.class);
    Mockito.when(underlying.simplifyType(type)).thenReturn(ComputationTargetType.SECURITY);
    assertSame(resolver.simplifyType(type), ComputationTargetType.SECURITY);
  }

  public void testGetVersionCorrection() {
    final ComputationTargetResolver.AtVersionCorrection underlying = Mockito.mock(ComputationTargetResolver.AtVersionCorrection.class);
    final ConcurrentMap<ComputationTargetReference, UniqueId> resolutions = new ConcurrentHashMap<ComputationTargetReference, UniqueId>();
    final Set<UniqueId> expiredResolutions = new HashSet<UniqueId>();
    final ComputationTargetResolver.AtVersionCorrection resolver = TargetResolutionLogger.of(underlying, resolutions, expiredResolutions);
    final VersionCorrection vc = VersionCorrection.of(Instant.now(), Instant.now());
    Mockito.when(underlying.getVersionCorrection()).thenReturn(vc);
    assertSame(resolver.getVersionCorrection(), vc);
  }

}