protected override void Context() { base.Context(); _simulationToUpdate = A.Fake <IMoBiSimulation>(); _templateBuildingBlock = A.Fake <IBuildingBlock>(); var rootContainer = createRootContainer(); _simulationToUpdate.Model.Root = rootContainer; _originalParameterFixedNotBelongingToTemplate = rootContainer.Parameter("P1"); _originalParameterFixedNotBelongingToTemplate.Value = 5; _originalParameterFixedUpdatedByTemplate = rootContainer.Parameter("P2"); _originalParameterFixedUpdatedByTemplate.Value = 8; _buildingBlockInfoTemplate = A.Fake <IBuildingBlockInfo>(); A.CallTo(() => _buildingBlockInfoTemplate.UntypedTemplateBuildingBlock).Returns(_templateBuildingBlock); //simulates the update command var container = createRootContainer(); _updatedParameterFixedNotBelongingToTemplate = container.Parameter(_originalParameterFixedNotBelongingToTemplate.Name); _updatedParameterFixedUpdatedByTemplate = container.Parameter(_originalParameterFixedUpdatedByTemplate.Name); A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(_updatedParameterFixedUpdatedByTemplate, _simulationToUpdate)).Returns(_buildingBlockInfoTemplate); A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(_updatedParameterFixedNotBelongingToTemplate, _simulationToUpdate)).Returns(A.Fake <IBuildingBlockInfo>()); A.CallTo(() => _simulationToUpdate.Update(A <IMoBiBuildConfiguration> ._, A <IModel> ._)).Invokes(x => { _simulationToUpdate.Model.Root = container; }); }
public void CheckForBuildingBlockChanges(IBuildingBlockInfo buildingBlockInfo, IBuildingBlock commitTargetBuildingBlock) { if (buildingBlockInfo.BuildingBlockChanged) { var typeName = _objectTypeResolver.TypeFor(commitTargetBuildingBlock); _dialogCreator.MessageBoxInfo(AppConstants.Dialog.PendingBuildingBlockChangesInfo(typeName, commitTargetBuildingBlock.Name)); } }
public void Edit(IBuildingBlockInfo <TBuildingBlock> buildingBlockInfo) { _buildingBlockInfo = buildingBlockInfo; _editedBuildingBlock = buildingBlockInfo.BuildingBlock; _originalTemplateBuildingBlock = buildingBlockInfo.TemplateBuildingBlock; _origialSimulationChanges = buildingBlockInfo.SimulationChanges; updateSelectionWithBuildingBlock(_editedBuildingBlock ?? allAvailableTemplateBlocks.FirstOrDefault()); }
private void checkTemplateBuildingBlock(IBuildingBlockInfo buildingBlockInfo) { if (!string.IsNullOrEmpty(buildingBlockInfo.TemplateBuildingBlockId)) { return; } buildingBlockInfo.TemplateBuildingBlockId = buildingBlockInfo.UntypedBuildingBlock.Id; buildingBlockInfo.UntypedTemplateBuildingBlock = buildingBlockInfo.UntypedBuildingBlock; }
protected override void Context() { base.Context(); _buildingBlockInfo = A.Fake <IBuildingBlockInfo>(); _classifiableSimulation = new ClassifiableSimulation(); _classifiableSimulation.Subject = new MoBiSimulation(); _treeNode = new BuildingBlockInfoNode(_buildingBlockInfo); _treeNode.ParentNode = new SimulationNode(_classifiableSimulation); }
protected override void Context() { base.Context(); _templateBuildingBlock = A.Fake <IBuildingBlock>(); _templateBuildingBlock.Name = "toto"; _sim = A.Fake <IMoBiSimulation>(); _buildingBlockInfo = A.Fake <IBuildingBlockInfo>(); A.CallTo(() => _sim.MoBiBuildConfiguration.BuildingInfoForTemplate(_templateBuildingBlock)).Returns(_buildingBlockInfo); A.CallTo(() => _project.SimulationsCreatedUsing(_templateBuildingBlock)).Returns(new[] { _sim }); }
private bool shouldUseTemplateForUpdate <T>(IBuildingBlockInfo <T> templateBuildingBlockInfo, IBuildingBlock templateBuildingBlock) where T : class, IBuildingBlock { if (templateBuildingBlockInfo.TemplateBuildingBlock == null) { return(false); } //only use template building block if the one previously used was the template itself or if the building block is unchanged in the simulation return(templateBuildingBlockInfo.TemplateBuildingBlock == templateBuildingBlock || !templateBuildingBlockInfo.BuildingBlockChanged); }
protected override void Context() { base.Context(); _project = A.Fake <IMoBiProject>(); var sim1 = A.Fake <IMoBiSimulation>(); _templateBuildingBlock = A.Fake <IBuildingBlock>(); _buildingBlockInfo = A.Fake <IBuildingBlockInfo>(); A.CallTo(() => _project.SimulationsCreatedUsing(_templateBuildingBlock)).Returns(new [] { sim1 }); A.CallTo(() => sim1.MoBiBuildConfiguration.BuildingInfoForTemplate(_templateBuildingBlock)).Returns(_buildingBlockInfo); }
protected void UpdateStartValueInfo <TBuildingBlock, TStartValue>(IBuildingBlockInfo <TBuildingBlock> info, TBuildingBlock selectedBuildingBlock) where TBuildingBlock : class, IStartValuesBuildingBlock <TStartValue> where TStartValue : class, IStartValue { info.SimulationChanges += (selectedBuildingBlock.Version - info.TemplateBuildingBlock.Version); if (changedDuringCreation(info.TemplateBuildingBlock, selectedBuildingBlock)) { info.SimulationChanges++; } info.BuildingBlock = selectedBuildingBlock; }
protected void Refresh(IBuildingBlockInfo <TBuildingBlock> startValueBuildingBlockInfo) { if (startValueBuildingBlockInfo.TemplateBuildingBlock == null) { return; } _templateStartValues = startValueBuildingBlockInfo.TemplateBuildingBlock.ToCache(); StartValues = _startValuesTask.CreateStartValuesForSimulation(_buildConfiguration); StartValues.Version = startValueBuildingBlockInfo.TemplateBuildingBlock.Version; _view.Description = AppConstants.Captions.TemporaryStartValuesBasedOn(_objectTypeResolver.TypeFor(StartValues), StartValues.Name); }
private void addConfigurationNodeUnder(ITreeNode buildConfigNode, IBuildingBlockInfo buildingBlockInfo) { var buildingBlock = buildingBlockInfo.UntypedBuildingBlock; var statusIcon = buildingBlockInfo.BuildingBlockChanged ? ApplicationIcons.RedOverlayFor(buildingBlock.Icon) : ApplicationIcons.GreenOverlayFor(buildingBlock.Icon); CreateFor(buildingBlockInfo) .WithIcon(statusIcon) .Under(buildConfigNode); }
protected override void Context() { base.Context(); _simulation = A.Fake <IMoBiSimulation>(); _simulation.Id = "toto"; _simulationStatusChangedEvent = new SimulationStatusChangedEvent(_simulation); _simulationNode = new Nodes.TextNode("Simulation"); var buildConfiguration = A.Fake <IMoBiBuildConfiguration>(); var spatialStructure = A.Fake <IMoBiSpatialStructure>().WithId("SpatialStructure"); spatialStructure.Version = 5; var templateSpatialStructure = A.Fake <IMoBiSpatialStructure>().WithId("TemplateSpatialStructure"); var spatialStructureInfo = new SpatialStructureInfo(); spatialStructureInfo.TemplateBuildingBlock = templateSpatialStructure; spatialStructureInfo.BuildingBlock = spatialStructure; buildConfiguration.SpatialStructureInfo = spatialStructureInfo; A.CallTo(() => buildConfiguration.BuildingInfoForTemplateById(spatialStructureInfo.TemplateBuildingBlockId)).Returns(spatialStructureInfo); var moleculesInfo = new MoleculesInfo(); var templateBuildingBlock = A.Fake <IMoleculeBuildingBlock>().WithId("TemplateMolecules"); var moleculeBuildingBlock = A.Fake <IMoleculeBuildingBlock>().WithId("Molecules"); moleculesInfo.TemplateBuildingBlock = templateBuildingBlock; moleculesInfo.BuildingBlock = moleculeBuildingBlock; A.CallTo(() => buildConfiguration.BuildingInfoForTemplateById(moleculesInfo.TemplateBuildingBlockId)).Returns(moleculesInfo); buildConfiguration.MoleculesInfo = moleculesInfo; A.CallTo(() => buildConfiguration.AllBuildingBlockInfos()).Returns(new IBuildingBlockInfo[] { spatialStructureInfo, moleculesInfo }); A.CallTo(() => buildConfiguration.HasChangedBuildingBlocks()).Returns(true); _buildingBlockInfoDTOChanged = spatialStructureInfo; _buildingBlockInfoDTOUnchanged = moleculesInfo; _treeView = A.Fake <IUxTreeView>(); var configNode = new BuildConfigurationNode(buildConfiguration).Under(_simulationNode); _nodeToChange = new BuildingBlockInfoNode(_buildingBlockInfoDTOChanged) .WithIcon(ApplicationIcons.SpatialStructureGreen) .Under(configNode); _nodeNotToChange = new BuildingBlockInfoNode(_buildingBlockInfoDTOUnchanged) .WithIcon(ApplicationIcons.MoleculeGreen) .Under(configNode); A.CallTo(() => _view.TreeView).Returns(_treeView); A.CallTo(() => _treeView.NodeById(_simulation.Id)).Returns(_simulationNode); A.CallTo(() => _simulation.MoBiBuildConfiguration).Returns(buildConfiguration); }
protected override void Context() { _affectedBuildingBlockRetriever = A.Fake <IAffectedBuildingBlockRetriever>(); _entityPathResolver = A.Fake <IEntityPathResolver>(); _context = A.Fake <IMoBiContext>(); sut = new QuantitySynchronizer(_affectedBuildingBlockRetriever, _entityPathResolver, _context); _simulation = A.Fake <IMoBiSimulation>(); _buildingBlockInfo = A.Fake <IBuildingBlockInfo>(); _objectPath = new ObjectPath("P"); A.CallTo(() => _entityPathResolver.ObjectPathFor(_parameter, false)).Returns(_objectPath); A.CallTo(() => _entityPathResolver.PathFor(_parameter)).Returns("P"); A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(_quantity, _simulation)).Returns(_buildingBlockInfo); }
private void updateFrom <T>(IBuildingBlockInfo <T> buildingBlockInfo, IBuildingBlockInfo <T> templateBuildingBlockInfo, IBuildingBlock templateBuildingBlock) where T : class, IBuildingBlock { var shouldUseTemplate = shouldUseTemplateForUpdate(templateBuildingBlockInfo, templateBuildingBlock); var buildingBlockToUse = shouldUseTemplate ? templateBuildingBlockInfo.TemplateBuildingBlock : templateBuildingBlockInfo.BuildingBlock; update(buildingBlockInfo, templateBuildingBlockInfo, buildingBlockToUse); //since we are using the template building block, we reset the simulation change counter if (shouldUseTemplate) { buildingBlockInfo.SimulationChanges = 0; } }
protected override void Context() { base.Context(); var buildConfiguration = A.Fake <IMoBiBuildConfiguration>(); var affectedBuildingBlock = new EventGroupBuildingBlock(); var eventGroupBuildingBlockInfo = new EventGroupBuildingBlockInfo() { BuildingBlock = affectedBuildingBlock }; _buildingBlockInfo = eventGroupBuildingBlockInfo; _simulation = new MoBiSimulation { BuildConfiguration = buildConfiguration, Model = A.Fake <IModel>() }; _changedQuantity = A.Fake <IQuantity>(); A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(A <IQuantity> ._, _simulation)).Returns(eventGroupBuildingBlockInfo); }
private void cloneTo <T>(IBuildingBlockInfo <T> buildingBlockInfo, IBuildingBlockInfo <T> templateBuildingBlockInfo) where T : class, IBuildingBlock { var buildingBlockToUse = templateBuildingBlockInfo.BuildingBlock; //this is a template building block, we need to clone it. Otherwise use as is if (templateBuildingBlockInfo.BuildingBlockIsTemplate) { buildingBlockToUse = clone(templateBuildingBlockInfo.TemplateBuildingBlock); } update(buildingBlockInfo, templateBuildingBlockInfo, buildingBlockToUse); //since we are using the template building block, we reset the simulation change counter if (templateBuildingBlockInfo.BuildingBlockIsTemplate) { buildingBlockInfo.SimulationChanges = 0; } _registerTask.RegisterAllIn(buildingBlockInfo.BuildingBlock); }
protected override void Context() { _context = A.Fake <IMoBiContext>(); _view = A.Fake <IBuildingBlockSelectionView>(); _buildingBlockRepository = A.Fake <IBuildingBlockRepository>(); _interactionTask = A.Fake <IInteractionTasksForBuildingBlock <IMoBiReactionBuildingBlock> >(); sut = new BuildingBlockSelectionPresenter <IMoBiReactionBuildingBlock>(_view, _buildingBlockRepository, _interactionTask, _context); _buildingBlockInfo = new ReactionBuildingBlockInfo(); _templateBuildingBlock1 = A.Fake <IMoBiReactionBuildingBlock>().WithName("BB1"); _templateBuildingBlock2 = A.Fake <IMoBiReactionBuildingBlock>().WithName("BB2"); _simulationBuildingBlock = A.Fake <IMoBiReactionBuildingBlock>().WithName("BBSIM"); _allBuildingBlocks = new List <IMoBiReactionBuildingBlock> { _templateBuildingBlock1, _templateBuildingBlock2 }; A.CallTo(() => _buildingBlockRepository.All <IMoBiReactionBuildingBlock>()).Returns(_allBuildingBlocks); A.CallTo(() => _view.BindTo(A <BuildingBlockSelectionDTO> ._)) .Invokes(x => _buildingBlockSelectionDTO = x.GetArgument <BuildingBlockSelectionDTO>(0)); }
protected override void Context() { _simulation = A.Fake <IMoBiSimulation>(); _buildingBlockInfoUpdater = A.Fake <IBuilingBlockReferenceUpdater>(); _oldTemplateBuildingBlock = A.Fake <IParameterStartValuesBuildingBlock>().WithName("OLD TEMPLATE"); _clonedSimulationBuildingBlock = A.Fake <IParameterStartValuesBuildingBlock>().WithName("CLONE SIMULATION"); _oldTemplateBuildingBlock.Version = 7; _clonedSimulationBuildingBlock.Version = 4; _simulationBuildingBlockInfo = A.Fake <IBuildingBlockInfo>(); _simulationBuildingBlockInfo.SimulationChanges = 5; _simulationBuildingBlockInfo.UntypedTemplateBuildingBlock = _oldTemplateBuildingBlock; _simulationBuildingBlock = A.Fake <IBuildingBlock>(); _simulationBuildingBlockInfo.UntypedBuildingBlock = _simulationBuildingBlock; _simulationBuildingBlock.Version = _clonedSimulationBuildingBlock.Version; _simulationBuildingBlock.Name = "TRALALA"; A.CallTo(_simulation.MoBiBuildConfiguration).WithReturnType <IBuildingBlockInfo>().Returns(_simulationBuildingBlockInfo); _context = A.Fake <IMoBiContext>(); A.CallTo(() => _context.Resolve <IBuilingBlockReferenceUpdater>()).Returns(_buildingBlockInfoUpdater); sut = new UpdateTemplateBuildingBlockFromSimulationBuildingBlockCommand <IParameterStartValuesBuildingBlock>(_oldTemplateBuildingBlock, _clonedSimulationBuildingBlock, _simulation); }
protected override void Context() { base.Context(); _project = A.Fake <IMoBiProject>(); var sim1 = A.Fake <IMoBiSimulation>(); var sim2 = A.Fake <IMoBiSimulation>(); _template1 = A.Fake <IBuildingBlock>().WithName("Template1"); _template2 = A.Fake <IBuildingBlock>().WithName("Template2"); _buildInfoSim1 = A.Fake <IBuildingBlockInfo>(); _buildInfoSim1.TemplateBuildingBlockId = "T1"; _buildInfoSim2 = A.Fake <IBuildingBlockInfo>(); _buildInfoSim2.TemplateBuildingBlockId = "T2"; A.CallTo(() => sim1.MoBiBuildConfiguration.AllBuildingBlockInfos()).Returns(new[] { _buildInfoSim1 }); A.CallTo(() => sim2.MoBiBuildConfiguration.AllBuildingBlockInfos()).Returns(new[] { _buildInfoSim2 }); A.CallTo(() => _project.Simulations).Returns(new[] { sim1, sim2 }); A.CallTo(() => _project.TemplateById(_buildInfoSim1.TemplateBuildingBlockId)).Returns(_template1); A.CallTo(() => _project.TemplateById(_buildInfoSim2.TemplateBuildingBlockId)).Returns(_template2); }
protected override void Because() { _result = sut.RetrieveFor(_passiveTransportParameter, _simulation); }
public ITreeNode CreateFor(IBuildingBlockInfo buildingBlockInfo) { return(new BuildingBlockInfoNode(buildingBlockInfo)); }
public BuildingBlockInfoViewItem(IBuildingBlockInfo buildingBlockInfoInfo, IMoBiSimulation simulation) { BuildingBlockInfo = buildingBlockInfoInfo; Simulation = simulation; }
protected override void Because() { _result = sut.RetrieveFor(new Parameter(), _simulation); }
/// <summary> /// Updates the start values defined in <paramref name="startValuesToUpdate" /> with the values defined in /// <paramref name="startValueInfo" />. Returns a template cache containg all values defined in the template /// </summary> public ICache <string, TStartValue> UpdateValuesFromTemplate(TBuildingBlock startValuesToUpdate, IBuildingBlockInfo <TBuildingBlock> startValueInfo) { var templateStartValues = startValueInfo.BuildingBlock; if (startValueInfo.BuildingBlockIsTemplate) { templateStartValues = startValueInfo.TemplateBuildingBlock; } var startValueCache = startValuesToUpdate.ToCache(); var templateCache = templateStartValues.ToCache(); _cloneManagerForBuildingBlock.FormulaCache = startValuesToUpdate.FormulaCache; try { foreach (var templateKeyValue in templateCache.KeyValues) { var startValue = startValueCache[templateKeyValue.Key]; if (startValue == null) { addStartValueToCache(startValuesToUpdate, templateKeyValue.Value); } else { startValue.UpdatePropertiesFrom(templateKeyValue.Value, _cloneManagerForBuildingBlock); } } startValuesToUpdate.Version = templateStartValues.Version; } finally { _cloneManagerForBuildingBlock.FormulaCache = null; } return(templateCache); }
protected override void Because() { _result = sut.RetrieveFor(A.Fake <IMoleculeAmount>(), _simulation); }
private IBuildingBlockInfo modeDependentInfo(IParameter parameter, IBuildingBlockInfo defautBuildingBlockInfo, IBuildingBlockInfo parameterStartValuesInfo) { return(parameter.BuildMode == ParameterBuildMode.Local ? parameterStartValuesInfo : defautBuildingBlockInfo); }
protected override void Because() { _result = sut.RetrieveFor(A.Fake <IObserver>(), _simulation); }
private T createForProject <T>(IReadOnlyCollection <T> projectBuildingBlocks, IBuildingBlockInfo <T> buildingBlockInfo) where T : class, IBuildingBlock { //this was already added to the project var templateBuildingBlock = projectBuildingBlocks.FindById(buildingBlockInfo.TemplateBuildingBlockId); if (templateBuildingBlock != null) { buildingBlockInfo.TemplateBuildingBlock = templateBuildingBlock; return(null); } templateBuildingBlock = buildingBlockInfo.BuildingBlock; if (!_nameCorrector.CorrectName(projectBuildingBlocks, templateBuildingBlock)) { return(null); } buildingBlockInfo.TemplateBuildingBlock = templateBuildingBlock; buildingBlockInfo.BuildingBlock = _cloneManager.CloneBuidingBlock(templateBuildingBlock); return(templateBuildingBlock); }
private void update <T>(IBuildingBlockInfo <T> buildingBlockInfo, IBuildingBlockInfo <T> templateBuildingBlockInfo, T usedBuildingBlock) where T : class, IBuildingBlock { buildingBlockInfo.BuildingBlock = usedBuildingBlock; buildingBlockInfo.TemplateBuildingBlock = templateBuildingBlockInfo.TemplateBuildingBlock; buildingBlockInfo.SimulationChanges = templateBuildingBlockInfo.SimulationChanges; }