protected override void Context()
{
base.Context();
_parentClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "parent"
};
_childEmptyClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "childEmpty", Parent = _parentClassification
};
_childClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "child", Parent = _parentClassification
};
_simulation = new ClassifiableSimulation {
Subject = new IndividualSimulation()
};
sut.AddClassificationsToTree(new[] { _childEmptyClassification, _parentClassification, _childClassification });
//do that after so that real node and node fakes are created when adding the classificaiton to the tree
_project.AddClassification(_childEmptyClassification);
_project.AddClassification(_parentClassification);
_project.AddClassification(_childClassification);
_childEmptyClassificationNode = _classificationNodesCache[_childEmptyClassification];
_childClassificationNode = _classificationNodesCache[_childClassification];
_parentClassificationNode = _childClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
_simulationNode = new SimulationNode(_simulation);
_childClassificationNode.AddChild(_simulationNode);
_parentClassificationNode = _childClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
A.CallTo(() => _explorerPresenter.NodeFor(_childEmptyClassification)).Returns(_childEmptyClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_childClassification)).Returns(_childClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_parentClassification)).Returns(_parentClassificationNode);
}
private string retrieveCategoryValue(ClassifiableSimulation classifiableSimulation, string category)
{
var simulation = classifiableSimulation.Simulation;
if (string.Equals(PKSimConstants.Classifications.Compound, category))
{
return(simulation.BuildingBlockName(PKSimBuildingBlockType.Compound));
}
if (string.Equals(PKSimConstants.Classifications.AdministrationProtocol, category))
{
return(simulation.BuildingBlockName(PKSimBuildingBlockType.Protocol));
}
if (string.Equals(PKSimConstants.Classifications.Individual, category))
{
return(simulation.BuildingBlockName(PKSimBuildingBlockType.Individual));
}
if (string.Equals(PKSimConstants.Classifications.Population, category))
{
return(simulation.BuildingBlockName(PKSimBuildingBlockType.Population));
}
if (string.Equals(PKSimConstants.Classifications.SimulationType, category))
{
return(displayTypeFor(simulation));
}
return(string.Empty);
}
protected override void Context()
{
base.Context();
_parentClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "parent"
};
_childClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "child", Parent = _parentClassification
};
sut.AddClassificationsToTree(new[] { _childClassification, _parentClassification });
//do that after so that real node and node fakes are created when adding the classificaiton to the tree
_project.AddClassification(_childClassification);
_project.AddClassification(_parentClassification);
_simulation = new ClassifiableSimulation {
Parent = _childClassification, Subject = A.Fake <ISimulation>().WithId("Sim")
};
_childClassificationNode = _classificationNodesCache[_childClassification];
_simulationNode = new SimulationNode(_simulation);
_childClassificationNode.AddChild(_simulationNode);
_parentClassificationNode = _childClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
}
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();
const string id = "myId";
_classifiableSimulation = new ClassifiableSimulation {
Id = id
};
sut.AddClassifiable(_classifiableSimulation);
_subject = new IndividualSimulation {
Id = id, Name = "name"
};
}
protected override void Context()
{
base.Context();
//create the following tree
//human => oral=>S1
//oral=>S2
_humanClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "human"
};
_humanOralClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "oral", Parent = _humanClassification
};
_oralClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "oral"
};
sut.AddClassificationsToTree(new[] { _humanOralClassification, _humanClassification, _oralClassification });
_project.AddClassification(_humanOralClassification);
_project.AddClassification(_humanClassification);
_project.AddClassification(_oralClassification);
_simulation1 = new ClassifiableSimulation {
Parent = _humanOralClassification, Subject = new IndividualSimulation {
Name = "S1"
}
};
_simulation2 = new ClassifiableSimulation {
Parent = _oralClassification, Subject = new IndividualSimulation {
Name = "S2"
}
};
_humanOralClassificationNode = _classificationNodesCache[_humanOralClassification];
_oralClassificationNode = _classificationNodesCache[_oralClassification];
_simulation1Node = new SimulationNode(_simulation1).Under(_humanOralClassificationNode);
_simulation2Node = new SimulationNode(_simulation2).Under(_oralClassificationNode);
_humanClassificationNode = _humanOralClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
A.CallTo(() => _explorerPresenter.NodeFor(_humanOralClassification)).Returns(_humanOralClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_oralClassification)).Returns(_oralClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_humanClassification)).Returns(_humanClassificationNode);
}
protected override void Context()
{
base.Context();
_simulation1 = new ClassifiableSimulation {
Subject = new IndividualSimulation {
Id = "1"
}
};
_simulation2 = new ClassifiableSimulation {
Subject = new IndividualSimulation {
Id = "2"
}
};
var parentClassification = new Classification {
ClassificationType = ClassificationType.Simulation
};
_simulation3WithParent = new ClassifiableSimulation {
Subject = new IndividualSimulation {
Id = "3"
}, Parent = parentClassification
};
_observedData = new ClassifiableObservedData {
Subject = new DataRepository()
};
_project.AddClassifiable(_simulation1);
_project.AddClassifiable(_simulation2);
_project.AddClassifiable(_simulation3WithParent);
_project.AddClassifiable(_observedData);
var simulationNode1 = new SimulationNode(_simulation1);
A.CallTo(() => _explorerPresenter.NodeFor(_simulation1)).Returns(simulationNode1);
var simulationNode2 = new SimulationNode(_simulation2);
A.CallTo(() => _explorerPresenter.NodeFor(_simulation2)).Returns(simulationNode2);
A.CallTo(() => _explorerPresenter.NodeFor(_simulation3WithParent)).Returns(new SimulationNode(_simulation3WithParent));
A.CallTo(() => _explorerPresenter.NodeFor(_observedData)).Returns(new ObservedDataNode(_observedData));
var parentClassificationNode = new ClassificationNode(parentClassification);
A.CallTo(() => _explorerPresenter.NodeFor(parentClassification)).Returns(parentClassificationNode);
_simulationFolderNode.AddChild(simulationNode1);
_simulationFolderNode.AddChild(simulationNode2);
_simulationFolderNode.AddChild(parentClassificationNode);
}
protected override void Context()
{
base.Context();
_originalClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "Original"
};
_targetClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "Target"
};
_simulation = new ClassifiableSimulation {
Parent = _originalClassification, Subject = A.Fake <ISimulation>().WithName("S1")
};
sut.AddClassificationsToTree(new[] { _originalClassification, _targetClassification });
_project.AddClassification(_originalClassification);
_project.AddClassification(_targetClassification);
_originalClassificationNode = _classificationNodesCache[_originalClassification];
_targetClassificationNode = _classificationNodesCache[_targetClassification];
_simulationNode = new SimulationNode(_simulation).Under(_originalClassificationNode);
}
public ITreeNode CreateFor(ClassifiableSimulation classifiableSimulation)
{
var simNode = new SimulationNode(classifiableSimulation);
var simulation = classifiableSimulation.Simulation;
if (simulation.MoBiBuildConfiguration.HasChangedBuildingBlocks())
{
simNode.Icon = ApplicationIcons.SimulationRed;
}
var buildConfigNode = CreateFor(simulation.MoBiBuildConfiguration);
simNode.AddChild(buildConfigNode);
if (simulation.Results != null)
{
simNode.AddChild(CreateFor(simulation.Results));
}
//uses reverse so that the first result is the last node
simulation.HistoricResults.Reverse().Each(res => simNode.AddChild(CreateFor(res)));
return(simNode);
}
protected override void Context()
{
_buildingBlockIconRetriever = A.Fake <IBuildingBlockIconRetriever>();
_view = A.Fake <ISimulationExplorerView>();
A.CallTo(() => _view.TreeView).Returns(A.Fake <IUxTreeView>());
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_contextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_regionResolver = A.Fake <IRegionResolver>();
_buildingBlockInSimulationManager = A.Fake <IBuildingBlockInSimulationManager>();
_buildingBlockTask = A.Fake <IBuildingBlockTask>();
_toolTipNodeCreator = A.Fake <IToolTipPartCreator>();
_projectRetriever = A.Fake <IProjectRetriever>();
_multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>();
_parameterAnalysablesInExplorerPresenter = A.Fake <IParameterAnalysablesInExplorerPresenter>();
_simulationComparisonTask = A.Fake <ISimulationComparisonTask>();
_simulationFolderNode = new RootNode(RootNodeTypes.SimulationFolder);
_comparisonFolderNode = new RootNode(RootNodeTypes.ComparisonFolder);
_project = new PKSimProject();
_usedObservedData = new UsedObservedData {
Id = "UsedData"
};
_simulation = new IndividualSimulation().WithName("individualSimulation").WithId("individualSimulation");
_populationSimulation = new PopulationSimulation().WithName("populationSimulation").WithId("populationSimulation");
_importedSimulaton = A.Fake <Simulation>().WithName("ImportedSimulation").WithId("ImportedSimulation");
A.CallTo(() => _importedSimulaton.IsImported).Returns(true);
_simulation.Properties = new SimulationProperties();
_simulation.ModelProperties = new ModelProperties();
_simulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_populationSimulation.Properties = new SimulationProperties();
_populationSimulation.ModelProperties = new ModelProperties();
_populationSimulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_classificationPresenter = A.Fake <IClassificationPresenter>();
_project.AddBuildingBlock(_simulation);
_project.AddBuildingBlock(_populationSimulation);
var classifiableIndividualSimulation = new ClassifiableSimulation {
Subject = _simulation
};
var classfiablePopulationSimulation = new ClassifiableSimulation {
Subject = _populationSimulation
};
var classifiableImportSimulation = new ClassifiableSimulation {
Subject = _importedSimulaton
};
_project.AddClassifiable(classifiableIndividualSimulation);
_project.AddClassifiable(classfiablePopulationSimulation);
_individualSimulationNode = new SimulationNode(classifiableIndividualSimulation);
_populationSimulationNode = new SimulationNode(classfiablePopulationSimulation);
_importedSimulationNode = new SimulationNode(classifiableImportSimulation);
_usedObservedDataNode = A.Fake <ITreeNode>();
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableIndividualSimulation)).Returns(_individualSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classfiablePopulationSimulation)).Returns(_populationSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableImportSimulation)).Returns(_importedSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(_usedObservedData)).Returns(_usedObservedDataNode);
_project.AddBuildingBlock(_importedSimulaton);
var simulationComparison = A.Fake <ISimulationComparison>().WithId("SimComp_Id");
var classifiableComparison = new ClassifiableComparison {
Subject = simulationComparison
};
_comparisonNode = new ComparisonNode(classifiableComparison);
_project.AddSimulationComparison(simulationComparison);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableComparison)).Returns(_comparisonNode);
_usedCompoundBuildingBlock = new UsedBuildingBlock("toto", PKSimBuildingBlockType.Compound)
{
Id = "usedBB"
};
_simulation.AddUsedBuildingBlock(_usedCompoundBuildingBlock);
_simulation.AddUsedObservedData(_usedObservedData);
_project.AddClassifiable(classifiableComparison);
_templageCompoundBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_usedBuildingBlockNode = new UsedBuildingBlockInSimulationNode(_simulation, _usedCompoundBuildingBlock, _templageCompoundBuildingBlock);
A.CallTo(() => _treeNodeFactory.CreateFor(_simulation, _usedCompoundBuildingBlock)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_simulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_populationSimulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_usedCompoundBuildingBlock)).Returns(ApplicationIcons.CompoundRed);
A.CallTo(() => _view.TreeView.NodeById(_simulation.Id)).Returns(_individualSimulationNode);
A.CallTo(() => _view.TreeView.NodeById(_usedCompoundBuildingBlock.Id)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.SimulationFolder.Id)).Returns(_simulationFolderNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.ComparisonFolder.Id)).Returns(_comparisonFolderNode);
_observedDataInSimulationManager = A.Fake <IObservedDataInSimulationManager>();
sut = new SimulationExplorerPresenter(
_view, _treeNodeFactory, _contextMenuFactory,
_multipleTreeNodeContextMenuFactory, _buildingBlockIconRetriever,
_regionResolver, _buildingBlockTask, _buildingBlockInSimulationManager,
_toolTipNodeCreator, _projectRetriever, _classificationPresenter,
_parameterAnalysablesInExplorerPresenter, _observedDataInSimulationManager, _simulationComparisonTask);
A.CallTo(() => _projectRetriever.CurrentProject).Returns(_project);
}
private ITreeNode addClassifiableSimulationToTree(ITreeNode <IClassification> classificationNode, ClassifiableSimulation classifiableSimulation)
{
var simulation = classifiableSimulation.Simulation;
var simulationNode = _treeNodeFactory.CreateFor(classifiableSimulation)
.WithIcon(_buildingBlockIconRetriever.IconFor(simulation));
addUsedBuildingBlockNodes(simulation, simulationNode);
AddClassifiableNodeToView(simulationNode, classificationNode);
updateObservedDataFor(simulationNode, simulation);
return(simulationNode);
}
private ITreeNode addClassifiableSimulationToRootFolder(ClassifiableSimulation classifiableSimulation)
{
return(AddClassifiableToTree(classifiableSimulation, RootNodeTypes.SimulationFolder, addClassifiableSimulationToTree));
}
public ITreeNode CreateFor(ClassifiableSimulation simulation) => new SimulationNode(simulation);
private ITreeNode addClassifiableSimulationToTree(ITreeNode <IClassification> classificationNode, ClassifiableSimulation classifiableSimulation)
{
var simulationNode = _treeNodeFactory.CreateFor(classifiableSimulation);
AddClassifiableNodeToView(simulationNode, classificationNode);
refreshDisplayedSimulation(classifiableSimulation.Simulation);
return(simulationNode);
}
public ITreeNode CreateFor(ClassifiableSimulation simulation)
{
//for a simulation node, we only need the info defined in the sim properties
return(new SimulationNode(simulation));
}
protected override void Because()
{
_result = sut.GetOrCreateClassifiableFor <ClassifiableSimulation, Simulation>(_subject);
}
