private static double GetValue(ValueRequirement req) { if (req.TargetSpecification.Type != ComputationTargetType.Primitive) throw new NotImplementedException(); using (var remoteClient = Context.CreateFinancialClient()) { var viewDefinition = new ViewDefinition(TestUtils.GetUniqueName()); var viewCalculationConfiguration = new ViewCalculationConfiguration("Default", new List<ValueRequirement> { req }, new Dictionary<string, HashSet<Tuple<string, ValueProperties>>>()); viewDefinition.CalculationConfigurationsByName.Add("Default", viewCalculationConfiguration); var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(viewDefinition)); viewDefinition.UniqueID = uid; try { using (var viewClient = Context.ViewProcessor.CreateClient()) { var viewComputationResultModel = viewClient.GetResults(viewDefinition.UniqueID, ExecutionOptions.SingleCycle).First(); return (double)viewComputationResultModel["Default", req].Value; } } finally { remoteClient.ViewDefinitionRepository.RemoveViewDefinition(viewDefinition.Name); } } }
public void CanGetAllKindsOfValues(ViewDefinition defn) { WithViewCycle( delegate(ViewDefinitionCompiledArgs compiled, IViewCycle cycle, RemoteViewClient client) { var compiledViewDefinition = cycle.GetCompiledViewDefinition(); foreach (var kvp in compiledViewDefinition.ViewDefinition.CalculationConfigurationsByName) { var viewCalculationConfiguration = kvp.Key; var dependencyGraphExplorer = compiledViewDefinition.GetDependencyGraphExplorer(viewCalculationConfiguration); Assert.NotNull(dependencyGraphExplorer); var wholeGraph = dependencyGraphExplorer.GetWholeGraph(); var distinctKindsOfSpec = wholeGraph.DependencyNodes.SelectMany(n => n.OutputValues) .ToLookup(s => s.ValueName).Select(g => g.First()); var specs = new HashSet<ValueSpecification>(distinctKindsOfSpec); if (! specs.Any()) { continue; } var computationCacheResponse = cycle.QueryComputationCaches(new ComputationCacheQuery(viewCalculationConfiguration, specs)); Assert.InRange(computationCacheResponse.Results.Count, 0, specs.Count()); foreach (var result in computationCacheResponse.Results) { Assert.Contains(result.First, specs); Assert.NotNull(result.Second); ValueAssertions.AssertSensibleValue(result.Second); } } }, defn.Name); }
public ViewDefinition CreateViewDefinition(RemoteEngineContext context, ValueRequirement valueRequirement) { var viewDefinition = new ViewDefinition(TestUtils.GetUniqueName()); viewDefinition.CalculationConfigurationsByName.Add("Default", new ViewCalculationConfiguration("Default", new List<ValueRequirement> { valueRequirement }, new Dictionary<string, HashSet<Tuple<string, ValueProperties>>>())); using (var remoteClient = context.CreateFinancialClient()) { var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(viewDefinition)); viewDefinition.UniqueID = uid; } _createdViews.Enqueue(Tuple.Create(context, viewDefinition.Name)); return viewDefinition; }
public void CanAttach(ViewDefinition vd) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { Assert.False(remoteViewClient.IsAttached); remoteViewClient.AttachToViewProcess(vd.UniqueID, ExecutionOptions.RealTime); Assert.True(remoteViewClient.IsAttached); remoteViewClient.DetachFromViewProcess(); Assert.False(remoteViewClient.IsAttached); } Thread.Sleep(TimeSpan.FromSeconds(10)); //[PLAT-1904] Try and wait for the compile to finish }
public void CanGetOutputs(ViewDefinition defn) { UniqueId portfolio = defn.PortfolioIdentifier; if (portfolio == null) { return; } var remoteAvailableOutputs = Context.RemoteAvailableOutputs; remoteAvailableOutputs.MaxNodes = 2; remoteAvailableOutputs.MaxPositions = 2; var availableOutputs = remoteAvailableOutputs.GetPortfolioOutputs(portfolio); Assert.NotNull(availableOutputs); foreach (var securityType in availableOutputs.SecurityTypes) { ICollection<AvailableOutput> positionOutputs = availableOutputs.GetPositionOutputs(securityType); Assert.NotEmpty(positionOutputs); foreach (var availableOutput in positionOutputs) { Assert.Null(availableOutput.PortfolioNodeProperties); Assert.True(new[] {securityType}.SequenceEqual(availableOutput.PositionProperties.Keys)); ValueProperties positionProperty = availableOutput.PositionProperties[securityType]; Assert.NotNull(positionProperty); Assert.NotNull(positionProperty.GetValues("Function")); } } ICollection<AvailableOutput> portfolioNodeOutputs = availableOutputs.GetPortfolioNodeOutputs(); Assert.NotNull(portfolioNodeOutputs); foreach (var availableOutput in portfolioNodeOutputs) { Assert.Empty(availableOutput.PositionProperties); ValueProperties properties = availableOutput.PortfolioNodeProperties; Assert.NotNull(properties); Assert.NotNull(properties.GetValues("Function")); } }
public void CanGetIsLiveComputationRunning(ViewDefinition definition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { Assert.Equal(ViewClientState.Started, remoteViewClient.GetState()); remoteViewClient.Pause(); Assert.Equal(ViewClientState.Paused, remoteViewClient.GetState()); remoteViewClient.Resume(); Assert.Equal(ViewClientState.Started, remoteViewClient.GetState()); } }
public void CanGetCompilationResults(ViewDefinition definition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var compilationResult = new BlockingCollection<object>(); var eventViewResultListener = new EventViewResultListener(); eventViewResultListener.ViewDefinitionCompiled += (sender, e) => compilationResult.Add(e.CompiledViewDefinition); eventViewResultListener.ViewDefinitionCompilationFailed += (sender, e) => compilationResult.Add(e.Exception); remoteViewClient.SetResultListener(eventViewResultListener); remoteViewClient.AttachToViewProcess(definition.UniqueID, ExecutionOptions.GetCompileOnly()); var result = compilationResult.Take(); Assert.IsNotType(typeof(Exception), result); Debug.WriteLine(definition.UniqueID); Assert.IsAssignableFrom(typeof(ICompiledViewDefinition), result); var viewDefin = (ICompiledViewDefinition)result; ValueAssertions.AssertSensibleValue(viewDefin); } }
public MarketDataSnapshotProcessor CreateFromViewDefinition(ViewDefinition definition, CancellationToken ct = default(CancellationToken)) { return MarketDataSnapshotProcessor.Create(_remoteEngineContext, definition, ct); }
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 void SetTemporaryName(ViewDefinition viewDefinition) { viewDefinition.Name = string.Format("{0}-RoundTripped-{1}", viewDefinition.Name, TestUtils.GetUniqueName()); viewDefinition.UniqueID = null; }
public void CanCreateFromView(ViewDefinition viewDefinition) { var snapshotManager = Context.MarketDataSnapshotManager; using (var proc = snapshotManager.CreateFromViewDefinition(viewDefinition)) { var manageableMarketDataSnapshot = proc.Snapshot; Assert.Null(manageableMarketDataSnapshot.Name); Assert.Null(manageableMarketDataSnapshot.UniqueId); Assert.True(manageableMarketDataSnapshot.Values.Any() || manageableMarketDataSnapshot.YieldCurves.Any(c => c.Value.Values.Values.Any()) || manageableMarketDataSnapshot.VolatilityCubes.Any(v => v.Value.Values.Any())); foreach (var valueSnapshot in manageableMarketDataSnapshot.Values) { foreach (var snapshot in valueSnapshot.Value) { ValueAssertions.AssertSensibleValue(snapshot.Value.MarketValue); Assert.Null(snapshot.Value.OverrideValue); } } if (viewDefinition.Name != "GlobeOp Bond View Implied" /* LAP-38 */ && viewDefinition.Name != "Simple Cash Test View 2" /* LAP-82 */) { Assert.InRange(manageableMarketDataSnapshot.YieldCurves.Count, ExpectedYieldCurves(viewDefinition), int.MaxValue); } if (viewDefinition.Name == "Equity Option Test View 1") { Assert.Equal(2, manageableMarketDataSnapshot.YieldCurves.Count); var yieldCurveSnapshot = manageableMarketDataSnapshot.YieldCurves.First(); Assert.NotNull(yieldCurveSnapshot); Assert.NotEmpty(yieldCurveSnapshot.Value.Values.Values); } foreach (var curve in manageableMarketDataSnapshot.YieldCurves.Values) { AssertSaneValue(curve); Assert.True(curve.Values.Values.Keys.Any(s => ! manageableMarketDataSnapshot.GlobalValues.Values.ContainsKey(s))); //LAP-37 } foreach (var cube in manageableMarketDataSnapshot.VolatilityCubes.Values) { Assert.True(cube.Values.Any(v => v.Value.MarketValue == null)); } } }
public UpdateViewDefinitionRequest(string name, ViewDefinition viewDefinition) { _name = name; _viewDefinition = viewDefinition; }
public void ViewResultsHaveSaneValues(ViewDefinition definition) { var viewComputationResultModel = GetOneResultCache.Get(definition.UniqueID); foreach (var viewResultEntry in viewComputationResultModel.AllResults) { ValueAssertions.AssertSensibleValue(viewResultEntry.ComputedValue.Value); } }
public void NumberOfResultsIsConsistent(ViewDefinition viewDefinition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var options = new ExecutionOptions(new InfiniteViewCycleExecutionSequence(), ViewExecutionFlags.TriggersEnabled | ViewExecutionFlags.AwaitMarketData, defaultExecutionOptions:new ViewCycleExecutionOptions(default(DateTimeOffset), new LiveMarketDataSpecification())); var resultsEnum = remoteViewClient.GetResults(viewDefinition.UniqueID, options); var results = resultsEnum.Take(3).ToList(); AssertNumberOfResultsIsConsistentOnRecompile(results); } }
public void UberView() { var defn = Context.ViewProcessor.ViewDefinitionRepository.GetViewDefinition("Mixed Instrument VaR View"); UniqueId portfolio = defn.PortfolioIdentifier; var remoteAvailableOutputs = Context.RemoteAvailableOutputs; remoteAvailableOutputs.MaxNodes = 2; remoteAvailableOutputs.MaxPositions = 2; var availableOutputs = remoteAvailableOutputs.GetPortfolioOutputs(portfolio); Assert.NotNull(availableOutputs); var valueNames = availableOutputs.SecurityTypes.ToDictionary(s => s, s => availableOutputs.GetPositionOutputs(s).Select(a => a.ValueName)); foreach (var securityType in availableOutputs.SecurityTypes) { ICollection<AvailableOutput> positionOutputs = availableOutputs.GetPositionOutputs(securityType); foreach (var availableOutput in positionOutputs) { Assert.Null(availableOutput.PortfolioNodeProperties); Assert.True(new[] { securityType }.SequenceEqual(availableOutput.PositionProperties.Keys)); ValueProperties positionProperty = availableOutput.PositionProperties[securityType]; Assert.NotNull(positionProperty); Assert.NotNull(positionProperty.GetValues("Function")); } } var viewCalculationConfiguration = GetDefaultCalculations(valueNames); var newDefn = new ViewDefinition(TestUtils.GetUniqueName(), portfolioIdentifier: portfolio, defaultCurrency: defn.DefaultCurrency, calculationConfigurationsByName: new Dictionary<string, ViewCalculationConfiguration> { { "Default", viewCalculationConfiguration } }); using (var remoteClient = Context.CreateFinancialClient()) { remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(newDefn)); RemoteViewCycleTests.WithViewCycle(delegate(ViewDefinitionCompiledArgs comp, IViewCycle cycle, RemoteViewClient client) { var allLiveData = cycle.GetResultModel().AllLiveData; var dependencyGraphExplorer = cycle.GetCompiledViewDefinition().GetDependencyGraphExplorer("Default"); var dependencyGraph = dependencyGraphExplorer.GetWholeGraph(); var dependencyNodes = dependencyGraph.DependencyNodes; var valueSpecifications = dependencyNodes.SelectMany(n => n.OutputValues).ToLookup(s => s).Select(g => g.Key).ToList(); Assert.NotEmpty(valueSpecifications); var first = cycle.QueryComputationCaches(new ComputationCacheQuery("Default", valueSpecifications)); Assert.InRange(allLiveData.Count(), 1, valueSpecifications.Count); Assert.InRange(first.Results.Count, allLiveData.Count() + 1, valueSpecifications.Count); }, defn.Name); } }
private static int ExpectedYieldCurves(ViewDefinition viewDefinition) { var yieldCurvesPerConfiguration = viewDefinition.CalculationConfigurationsByName.Select( c => c.Value.SpecificRequirements.Where(r => r.ValueName.Contains("YieldCurve") && r.ValueName != ValueRequirementNames.YieldCurveJacobian).Count()); return yieldCurvesPerConfiguration.Distinct().Max(); }
public void NumberOfResultsIsConsistent(ViewDefinition defn) { const int cyclesCount = 5; using (var remoteViewClient = Context.ViewProcessor.CreateClient()) using (var mre = new ManualResetEvent(false)) { var cycles = new BlockingCollection<IEngineResourceReference<IViewCycle>>(); var listener = new EventViewResultListener(); listener.ProcessCompleted += delegate { mre.Set(); }; listener.ViewDefinitionCompilationFailed += delegate { mre.Set(); }; listener.CycleExecutionFailed += delegate { mre.Set(); }; listener.CycleCompleted += (sender, e) => { cycles.Add(remoteViewClient.CreateCycleReference(e.FullResult.ViewCycleId)); remoteViewClient.TriggerCycle(); }; remoteViewClient.SetResultListener(listener); remoteViewClient.SetViewCycleAccessSupported(true); var sequence = ArbitraryViewCycleExecutionSequence.Create(Enumerable.Range(0, cyclesCount).Select(i => DateTimeOffset.Now + TimeSpan.FromHours(i))); var options = new ExecutionOptions(sequence, ViewExecutionFlags.TriggersEnabled | ViewExecutionFlags.AwaitMarketData, null, new ViewCycleExecutionOptions(default(DateTimeOffset), ExecutionOptions.GetDefaultMarketDataSpec())); remoteViewClient.AttachToViewProcess(defn.UniqueID, options); TimeSpan timeout = TimeSpan.FromMinutes(5); if (! mre.WaitOne(timeout)) { throw new TimeoutException(string.Format("Failed to get result in {0}", timeout)); } Assert.Equal(cyclesCount, cycles.Count); var specs = cycles.Select(GetAllSpecs).ToList(); var inconsistent = specs.Zip(specs.Skip(1), Tuple.Create).SelectMany( t => { var diff = new HashSet<Tuple<string, ValueSpecification>>(t.Item1); diff.SymmetricExceptWith(t.Item2); return diff; }).Distinct(); if (inconsistent.Any()) { var counts = string.Join(",", specs.Select(c => c.Count.ToString())); var inconsistentStrings = specs.Select(s => string.Join(",", s.Where(x => inconsistent.Contains(x)).Select(x => x.ToString()))); string inconsistentString = string.Join(Environment.NewLine, inconsistentStrings); throw new Exception(string.Format("Inconsistent number of results for {0} {1}: {2}", defn.Name, counts, inconsistentString)); } } }
public void CanGetAllTerminalValues(ViewDefinition defn) { WithViewCycle( delegate(ViewDefinitionCompiledArgs compiled, IViewCycle cycle, RemoteViewClient client) { var compiledViewDefinition = cycle.GetCompiledViewDefinition(); var viewComputationResultModel = cycle.GetResultModel(); foreach (var kvp in compiledViewDefinition.ViewDefinition.CalculationConfigurationsByName) { var viewCalculationConfiguration = kvp.Key; var results = viewComputationResultModel.AllResults.Where(r => r.CalculationConfiguration == viewCalculationConfiguration).ToDictionary(r => r.ComputedValue.Specification, r => r.ComputedValue.Value); var specs = results.Select(r => r.Key).ToList(); var computationCacheResponse = cycle.QueryComputationCaches(new ComputationCacheQuery(viewCalculationConfiguration, specs)); Assert.Equal(specs.Count(), computationCacheResponse.Results.Count); foreach (var result in computationCacheResponse.Results) { Assert.Contains(result.First, specs); var expected = results[result.First]; Assert.Equal(expected.GetType(), result.Second.GetType()); if (expected is double) { Assert.Equal(expected, result.Second); } } } }, defn.Name); }
public void CanGetManyResults(ViewDefinition viewDefinition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var options = ExecutionOptions.RealTime; var resultsEnum = remoteViewClient.GetResults(viewDefinition.UniqueID, options); var results = resultsEnum.Take(5).ToList(); Assert.True(results.All(r => r != null)); } }
private static void AssertDefinitionContains(ViewDefinition viewDefinition, ViewResultEntry viewResultEntry) { var configuration = viewDefinition.CalculationConfigurationsByName[viewResultEntry.CalculationConfiguration]; var valueSpecification = viewResultEntry.ComputedValue.Specification; foreach (var req in configuration.SpecificRequirements) { bool matches = (req.TargetSpecification.Uid == valueSpecification.TargetSpecification.Uid && req.TargetSpecification.Type == valueSpecification.TargetSpecification.Type && req.ValueName == valueSpecification.ValueName) && req.Constraints.IsSatisfiedBy(valueSpecification.Properties); if (matches) return; } var reqsByType = configuration.PortfolioRequirementsBySecurityType; if (!reqsByType.Any(r => r.Value.Any(t => t.Item1 == valueSpecification.ValueName))) { Assert.True(false, string.Format("Unmatched requirement {0},{1},{2} on {3}", valueSpecification.ValueName, valueSpecification.TargetSpecification.Type, valueSpecification.TargetSpecification.Uid, viewDefinition.Name)); } }
public void CanStartAndGetAResultOrCompilationFailure(ViewDefinition definition) { try { Assert.NotNull(GetOneResultCache.Get(definition.UniqueID)); } catch (Exception ex) { //Compilation failure is allowed, we will check that some views run elsewhere Assert.Contains("ViewDefinitionCompilationFailedArgs", ex.Message); } }
internal static MarketDataSnapshotProcessor Create(RemoteEngineContext context, ViewDefinition definition, CancellationToken ct) { using (var liveDataStream = new LiveDataStream(definition.Name, context)) { ManageableMarketDataSnapshot snapshot = liveDataStream.GetNewSnapshotForUpdate(ct); //NOTE: we could consider reusing the LiveDataStream, but server side will share the processer return new MarketDataSnapshotProcessor(context, snapshot); } }
public void NumberOfResultsIsConsistentOnRecompile(ViewDefinition viewDefinition) { var results = new List<IViewComputationResultModel>(); var viewProcess = new HashSet<UniqueId>(); for (int i = 0; i < 10; i++) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { var options = ExecutionOptions.SingleCycle; var resultsEnum = remoteViewClient.GetResults(viewDefinition.UniqueID, options, true); var result = resultsEnum.Take(1).ToList().Single(); if (!viewProcess.Add(result.ViewProcessId)) { throw new Exception("Shared process"); } results.Add(result); } } AssertNumberOfResultsIsConsistentOnRecompile(results); }
public AddViewDefinitionRequest(ViewDefinition viewDefinition) { _viewDefinition = viewDefinition; }
public void ViewResultsMatchDefinition(ViewDefinition viewDefinition) { using (var remoteViewClient = Context.ViewProcessor.CreateClient()) { ICompiledViewDefinition compiledViewDefinition = null; IViewComputationResultModel viewComputationResultModel = null; var resultsReady = new ManualResetEvent(false); var listener = new EventViewResultListener(); listener.ViewDefinitionCompiled += delegate(object sender, ViewDefinitionCompiledArgs e) { compiledViewDefinition = e.CompiledViewDefinition; }; listener.CycleCompleted += delegate(object sender, CycleCompletedArgs e) { viewComputationResultModel = e.FullResult; resultsReady.Set(); }; remoteViewClient.SetResultListener(listener); remoteViewClient.AttachToViewProcess(viewDefinition.UniqueID, ExecutionOptions.RealTime); if (!resultsReady.WaitOne(TimeSpan.FromMinutes(2))) throw new TimeoutException("Failed to get results for " + viewDefinition.Name + " client " + remoteViewClient.GetUniqueId()); Assert.NotNull(compiledViewDefinition); foreach (var viewResultEntry in viewComputationResultModel.AllResults) { Assert.NotNull(viewResultEntry.ComputedValue.Value); AssertDefinitionContains(viewDefinition, viewResultEntry); } var countActualValues = viewComputationResultModel.AllResults.Count(); var countMaxExpectedValues = CountMaxExpectedValues(compiledViewDefinition); Console.Out.WriteLine("{0} {1} {2}", viewDefinition.Name, countActualValues, countMaxExpectedValues); Assert.InRange(countActualValues, 1, countMaxExpectedValues); } }
public void CanGetYieldCurveValues(ViewDefinition viewDefinition) { var snapshotManager = Context.MarketDataSnapshotManager; using (var dataSnapshotProcessor = snapshotManager.CreateFromViewDefinition(viewDefinition)) { GetAndCheckYieldCurves(dataSnapshotProcessor); } }
public void CanUpdateFromLiveDataStream(ViewDefinition viewDefinition) { var snapshotManager = Context.MarketDataSnapshotManager; using (var dataSnapshotProcessor = snapshotManager.CreateFromViewDefinition(viewDefinition)) { UpdateAction<ManageableMarketDataSnapshot> prepareUpdate = dataSnapshotProcessor.PrepareUpdate(); var before = GetCount(dataSnapshotProcessor); prepareUpdate.Execute(dataSnapshotProcessor.Snapshot); var after = GetCount(dataSnapshotProcessor); Assert.Equal(before, after); } }
public void CanCreateAndRunFromView(ViewDefinition vd) { var snapshotManager = Context.MarketDataSnapshotManager; using (var proc = snapshotManager.CreateFromViewDefinition(vd.Name)) { proc.Snapshot.Name = TestUtils.GetUniqueName(); var uid = Context.MarketDataSnapshotMaster.Add(new MarketDataSnapshotDocument(null, proc.Snapshot)).UniqueId; try { var snapOptions = ExecutionOptions.Snapshot(proc.Snapshot.UniqueId); var withSnapshot = GetFirstResult(snapOptions, vd.Name); var options = ExecutionOptions.SingleCycle; IViewComputationResultModel withoutSnapshot = GetFirstResult(options, vd.Name); var withoutCount = CountResults(withoutSnapshot); var withCount = CountResults(withSnapshot); if (withoutCount != withCount) { var withSpecs = new HashSet<ValueSpecification>(withSnapshot.AllResults.Select(r => r.ComputedValue.Specification)); var withoutSpecs = new HashSet<ValueSpecification>(withoutSnapshot.AllResults.Select(r => r.ComputedValue.Specification)); withoutSpecs.SymmetricExceptWith(withSpecs); Assert.True(false, string.Format("Running snapshot of {0} only had {1}, live had {2}", vd.Name, withCount, withoutCount)); } Assert.Equal(withoutCount, withCount); } finally { Context.MarketDataSnapshotMaster.Remove(uid); } } }