/**
* Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.engine.marketdata.historical;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import static org.testng.AssertJUnit.assertEquals;
import java.util.Collections;
import java.util.Set;
import org.testng.annotations.Test;
import org.threeten.bp.LocalDate;
import com.google.common.collect.ImmutableSet;
import com.opengamma.core.historicaltimeseries.HistoricalTimeSeriesResolver;
import com.opengamma.core.historicaltimeseries.HistoricalTimeSeriesSource;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.marketdata.MarketDataListener;
import com.opengamma.engine.marketdata.MarketDataPermissionProvider;
import com.opengamma.engine.marketdata.MarketDataProvider;
import com.opengamma.engine.marketdata.MarketDataSnapshot;
import com.opengamma.engine.marketdata.spec.MarketDataSpecification;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.engine.value.ValueProperties;
import com.opengamma.engine.value.ValuePropertyNames;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.id.UniqueId;
import com.opengamma.livedata.UserPrincipal;
import com.opengamma.util.test.TestGroup;
@Test(groups = TestGroup.UNIT)
public class HistoricalShockMarketDataProviderTest {
private static final ValueSpecification SPEC1 =
new ValueSpecification("valueName1",
new ComputationTargetSpecification(ComputationTargetType.CURRENCY, UniqueId.of("id", "1")),
ValueProperties.with(ValuePropertyNames.FUNCTION, "function1").get());
private static final ValueSpecification SPEC2 =
new ValueSpecification("valueName2",
new ComputationTargetSpecification(ComputationTargetType.PORTFOLIO, UniqueId.of("id", "2")),
ValueProperties.with(ValuePropertyNames.FUNCTION, "function2").get());
private static final ValueSpecification SPEC3 =
new ValueSpecification("valueName3",
new ComputationTargetSpecification(ComputationTargetType.POSITION, UniqueId.of("id", "3")),
ValueProperties.with(ValuePropertyNames.FUNCTION, "function3").get());
private static final ValueSpecification SPEC4 =
new ValueSpecification("valueName4",
new ComputationTargetSpecification(ComputationTargetType.POSITION, UniqueId.of("id", "4")),
ValueProperties.with(ValuePropertyNames.FUNCTION, "function4").get());
@Test
public void permissionProvider() {
MarketDataProvider historicalProvider1 = mock(MarketDataProvider.class);
MarketDataProvider historicalProvider2 = mock(MarketDataProvider.class);
MarketDataProvider baseProvider = mock(MarketDataProvider.class);
MarketDataPermissionProvider pp1 = mock(MarketDataPermissionProvider.class);
MarketDataPermissionProvider pp2 = mock(MarketDataPermissionProvider.class);
MarketDataPermissionProvider pp3 = mock(MarketDataPermissionProvider.class);
when(historicalProvider1.getPermissionProvider()).thenReturn(pp1);
when(historicalProvider2.getPermissionProvider()).thenReturn(pp2);
when(baseProvider.getPermissionProvider()).thenReturn(pp3);
Set<ValueSpecification> specs = ImmutableSet.of(SPEC1, SPEC2, SPEC3, SPEC4);
when(pp1.checkMarketDataPermissions(UserPrincipal.getTestUser(), specs)).thenReturn(Collections.singleton(SPEC1));
when(pp2.checkMarketDataPermissions(UserPrincipal.getTestUser(), specs)).thenReturn(Collections.singleton(SPEC2));
when(pp3.checkMarketDataPermissions(UserPrincipal.getTestUser(), specs)).thenReturn(Collections.singleton(SPEC3));
HistoricalShockMarketDataProvider provider =
new HistoricalShockMarketDataProvider(historicalProvider1, historicalProvider2, baseProvider);
assertEquals(ImmutableSet.of(SPEC1, SPEC2, SPEC3),
provider.getPermissionProvider().checkMarketDataPermissions(UserPrincipal.getTestUser(), specs));
}
@Test
public void subscribe() {
Provider provider1 = new Provider();
Provider provider2 = new Provider();
Provider baseProvider = new Provider();
HistoricalShockMarketDataProvider shockProvider = new HistoricalShockMarketDataProvider(provider1, provider2, baseProvider);
MarketDataListener listener = mock(MarketDataListener.class);
shockProvider.addListener(listener);
provider1.valueChanged(SPEC1);
verify(listener).valuesChanged(Collections.singleton(SPEC1));
provider1.valueChanged(SPEC2);
verify(listener).valuesChanged(Collections.singleton(SPEC2));
provider2.valueChanged(SPEC3);
verify(listener).valuesChanged(Collections.singleton(SPEC3));
baseProvider.valueChanged(SPEC4);
verify(listener).valuesChanged(Collections.singleton(SPEC4));
shockProvider.removeListener(listener);
provider1.valueChanged(SPEC1);
verifyNoMoreInteractions(listener);
}
private static class Provider extends AbstractHistoricalMarketDataProvider {
private Provider() {
super(mock(HistoricalTimeSeriesSource.class), mock(HistoricalTimeSeriesResolver.class));
}
@Override
protected LocalDate getHistoricalResolutionDate(MarketDataSpecification marketDataSpec) {
throw new UnsupportedOperationException("getHistoricalResolutionDate not implemented");
}
@Override
public MarketDataSnapshot snapshot(MarketDataSpecification marketDataSpec) {
throw new UnsupportedOperationException("snapshot not implemented");
}
@Override
public void valueChanged(ValueSpecification specification) {
super.valueChanged(specification);
}
}
}