public void TestOptionalValues()
{
AssertEncodeDecodeCycle(
ValueProperties.Create(new Dictionary <string, ISet <string> >
{
{ "OptAny", new HashSet <string>() },
{ "OptSome", new HashSet <string> {
"a"
} },
}, new HashSet <string> {
"OptAny", "OptSome"
}));
}
public void TestValues()
{
AssertEncodeDecodeCycle(
ValueProperties.Create(new Dictionary <string, ISet <string> >
{
{ "Any", new HashSet <string>() },
{ "One", new HashSet <string> {
"a"
} },
{ "Two", new HashSet <string> {
"b", "c"
} },
}, new HashSet <string> {
"Three"
}));
}
public ViewCalculationConfiguration(string name, IEnumerable <ValueRequirement> specificRequirements, Dictionary <string, HashSet <Tuple <string, ValueProperties> > > portfolioRequirementsBySecurityType, DeltaDefinition deltaDefinition)
: this(name, specificRequirements, portfolioRequirementsBySecurityType, deltaDefinition, ValueProperties.Create(), null)
{
}
public void TestEmptyProperties()
{
AssertEncodeDecodeCycle(ValueProperties.Create());
}
public void CanGetUSDVolatilityCube(string currencyName)
{
const string cubeName = "BLOOMBERG";
var valueProperties = ValueProperties.Create(new Dictionary <string, ISet <string> > {
{ "Cube", new HashSet <string> {
cubeName
} }
}, new HashSet <string>());
var viewCalculationConfiguration = new ViewCalculationConfiguration("Default",
new[]
{
new ValueRequirement("VolatilityCubeMarketData", new ComputationTargetSpecification(ComputationTargetType.Primitive, Currency.Create(currencyName).UniqueId), valueProperties)
}, new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >());
var vdName = string.Join("-", TestUtils.GetUniqueName(), cubeName, currencyName);
var defn = new ViewDefinition(vdName, new ResultModelDefinition(ResultOutputMode.TerminalOutputs),
calculationConfigurationsByName:
new Dictionary <string, ViewCalculationConfiguration> {
{ "Default", viewCalculationConfiguration }
}, maxFullCalcPeriod: TimeSpan.FromSeconds(1));
using (var remoteClient = Context.CreateFinancialClient())
{
var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(defn));
defn.UniqueID = uid;
try
{
using (var remoteViewClient = Context.ViewProcessor.CreateClient())
{
var viewComputationResultModels = remoteViewClient.GetResults(defn.UniqueID, new ExecutionOptions(new InfiniteViewCycleExecutionSequence(), ViewExecutionFlags.AwaitMarketData | ViewExecutionFlags.TriggersEnabled, null, new ViewCycleExecutionOptions(default(DateTimeOffset), new LiveMarketDataSpecification())));
int i = 0;
foreach (var viewComputationResultModel in viewComputationResultModels)
{
if (viewComputationResultModel.AllLiveData.Any())
{
var liveDataCount = viewComputationResultModel.AllLiveData.Count();
if (liveDataCount > 10 && liveDataCount == i)
{
var volatilityCubeData = (VolatilityCubeData)viewComputationResultModel.AllResults.Single().ComputedValue.Value;
Assert.InRange(volatilityCubeData.DataPoints.Count, 1, int.MaxValue);
Assert.InRange(volatilityCubeData.Strikes.Count, 1, int.MaxValue);
Assert.Empty(volatilityCubeData.OtherData.DataPoints);
var actual = volatilityCubeData.DataPoints.Count + volatilityCubeData.OtherData.DataPoints.Count + volatilityCubeData.Strikes.Count;
Assert.InRange(actual, liveDataCount * 0.5, liveDataCount); //Allow 50% for PLAT-1383
var pays = volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike < 0);
var recvs = volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike > 0);
Assert.NotEmpty(pays);
Assert.NotEmpty(volatilityCubeData.DataPoints.Where(k => k.Key.RelativeStrike == 0));
Assert.NotEmpty(recvs);
foreach (var dataPoint in volatilityCubeData.DataPoints.Keys)
{
var strike = volatilityCubeData.Strikes[GetStrikeKey(dataPoint)];
Assert.True(strike > 0.0);
}
break;
}
i = liveDataCount;
}
}
}
}
finally
{
remoteClient.ViewDefinitionRepository.RemoveViewDefinition(defn.Name);
}
}
}
private static ViewCalculationConfiguration GetDefaultCalculations(Dictionary <string, IEnumerable <string> > valueNames)
{
Dictionary <string, HashSet <Tuple <string, ValueProperties> > > portfolioRequirementsBySecurityType = valueNames.ToDictionary(k => k.Key, k => new HashSet <Tuple <string, ValueProperties> >(k.Value.Select(v => Tuple.Create(v, ValueProperties.Create()))));
return(new ViewCalculationConfiguration("Default", new ValueRequirement[] { }, portfolioRequirementsBySecurityType));
}
