public UsedBuidlingBlockInSimulationContextMenu(Simulation simulation, UsedBuildingBlock usedBuildingBlock, TBuildingBlock templateBuildingBlock)
{
_simulation = simulation;
_usedBuildingBlock = usedBuildingBlock;
_templateBuildingBlock = templateBuildingBlock;
AllMenuItemsFor(_usedBuildingBlock, _templateBuildingBlock).Each(_view.AddMenuItem);
}
protected override void Context()
{
base.Context();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
A.CallTo(() => _templateBuildingBlock.StructureVersion).Returns(5);
A.CallTo(() => _templateBuildingBlock.Id).Returns("templateId");
_sameIdAndStructVersionUsedBuildingBlock = new UsedBuildingBlock(_templateBuildingBlock.Id, PKSimBuildingBlockType.Compound);
_sameIdAndStructVersionUsedBuildingBlock.StructureVersion = _templateBuildingBlock.StructureVersion;
_sameIdAndOtherStructVersionUsedBuildingBlock = new UsedBuildingBlock(_templateBuildingBlock.Id, PKSimBuildingBlockType.Compound);
_sameIdAndOtherStructVersionUsedBuildingBlock.StructureVersion = 2;
_otherIdAndSameStructVersionUsedBuildingBlock = new UsedBuildingBlock("another id", PKSimBuildingBlockType.Compound);
_otherIdAndSameStructVersionUsedBuildingBlock.StructureVersion = _templateBuildingBlock.StructureVersion;
_otherIdAndOtherSameStructVersionUsedBuildingBlock = new UsedBuildingBlock("another id", PKSimBuildingBlockType.Compound);
_otherIdAndOtherSameStructVersionUsedBuildingBlock.StructureVersion = 3;
_templateProtocol = new SimpleProtocol().WithId("_templateProtocol");
_templateProtocol.StructureVersion = 4;
_templatePopulation = new RandomPopulation().WithId("_templatePopulation");
_templatePopulation.StructureVersion = 4;
_usedProtocolBuildingBlock = new UsedBuildingBlock(_templateProtocol.Id, PKSimBuildingBlockType.Protocol);
_usedProtocolBuildingBlock.StructureVersion = _templateProtocol.StructureVersion;
_usedPopulationBuildingBlock = new UsedBuildingBlock(_templatePopulation.Id, PKSimBuildingBlockType.Population);
_usedPopulationBuildingBlock.StructureVersion = _templatePopulation.StructureVersion;
}
protected override void Context()
{
_executionContext = A.Fake <IExecutionContext>();
_simulationBuildingBlockUpdater = A.Fake <ISimulationBuildingBlockUpdater>();
_buildingBlockInProjectManager = A.Fake <IBuildingBlockInProjectManager>();
sut = new MultipleUsedBuildingBlockNodeContextMenuFactory(_buildingBlockInProjectManager, _executionContext);
_usedBuildingBlocksTreeNode = new List <ITreeNode>();
_presenter = A.Fake <IPresenterWithContextMenu <IReadOnlyList <ITreeNode> > >();
_buildingBlock1 = A.Fake <IPKSimBuildingBlock>().WithId("bb1");
_buildingBlock2 = A.Fake <IPKSimBuildingBlock>().WithId("bb2");
_buildingBlock3 = A.Fake <IPKSimBuildingBlock>().WithId("bb3");
_usedIndividual1 = new UsedBuildingBlock("1", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _buildingBlock1
};
_usedIndividual2 = new UsedBuildingBlock("2", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _buildingBlock2
};
_usedCompound1 = new UsedBuildingBlock("3", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _buildingBlock3
};
_command = new CompareObjectsUICommand(A.Fake <IEventPublisher>());
A.CallTo(() => _container.Resolve <CompareObjectsUICommand>()).Returns(_command);
A.CallTo(() => _executionContext.Resolve <ISimulationBuildingBlockUpdater>()).Returns(_simulationBuildingBlockUpdater);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <Simulation>();
_bb = new UsedBuildingBlock("toto", PKSimBuildingBlockType.Compound);
A.CallTo(() => _buildingBlockRetriever.BuildingBlockWithId(_bb.TemplateId)).Returns(A.Fake <IPKSimBuildingBlock>());
}
public UsedBuildingBlockInSimulationNode(Simulation simulation, UsedBuildingBlock usedBuildingBlock, IPKSimBuildingBlock templateBuildingBlock)
{
TemplateBuildingBlock = templateBuildingBlock;
//Do not store the used building block id itself since lazy loading might overwrite building block in simulation.
//We will always retrieve the building block from its id
_usedBuildingBlockId = usedBuildingBlock.Id;
Simulation = simulation;
}
protected override void Context()
{
base.Context();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_usedBuildingBlock = new UsedBuildingBlock("X", PKSimBuildingBlockType.Protocol);
_simulation = A.Fake <Simulation>();
A.CallTo(() => _simulationBuildingBlockUpdater.BuildingBlockSupportsQuickUpdate(_templateBuildingBlock)).Returns(false);
}
public ITreeNode CreateFor(Simulation simulation, UsedBuildingBlock usedBuildingBlock)
{
var templateBuildingBlock = _buildingBlockRetriever.BuildingBlockWithId(usedBuildingBlock.TemplateId);
return(new UsedBuildingBlockInSimulationNode(simulation, usedBuildingBlock, templateBuildingBlock)
{
ToolTip = _toolTipPartCreator.ToolTipFor(usedBuildingBlock)
});
}
protected override void Because()
{
_resultWithSameVersion = sut.StatusFor(_usedBuildingBlock);
_usedBuildingBlock = new UsedBuildingBlock(_templateBuildingBlock.Id, _templateBuildingBlock.BuildingBlockType)
{
Altered = true
};
_resultWithDifferentVersion = sut.StatusFor(_usedBuildingBlock);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <Simulation>();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_updateCommand = A.Fake <IPKSimCommand>();
_usedBuildingBlock = A.Fake <UsedBuildingBlock>();
A.CallTo(() => _simulationBuildingBlockUpdater.QuickUpdatePossibleFor(_templateBuildingBlock, _usedBuildingBlock)).Returns(true);
A.CallTo(() => _blockParametersToSimulationUpdater.UpdateParametersFromBuildingBlockInSimulation(_templateBuildingBlock, _simulation)).Returns(_updateCommand);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <Simulation>();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_project = A.Fake <PKSimProject>();
A.CallTo(() => _executionContext.CurrentProject).Returns(_project);
_usedBuildingBlock = A.Fake <UsedBuildingBlock>();
A.CallTo(() => _simulationBuildingBlockUpdater.QuickUpdatePossibleFor(_templateBuildingBlock, _usedBuildingBlock)).Returns(false);
}
protected override void Context()
{
base.Context();
_buildingBlockDefinedInSimulation = A.Fake <IPKSimBuildingBlock>();
A.CallTo(() => _buildingBlockDefinedInSimulation.Id).Returns("Id");
A.CallTo(() => _buildingBlockDefinedInSimulation.Version).Returns(5);
A.CallTo(() => _buildingBlockDefinedInSimulation.StructureVersion).Returns(8);
A.CallTo(() => _buildingBlockRepository.All()).Returns(new List <IPKSimBuildingBlock>());
_oldUsedBuildingBlock = A.Fake <UsedBuildingBlock>();
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <IndividualSimulation>();
_usedBB1 = A.Fake <UsedBuildingBlock>();
_usedBB2 = A.Fake <UsedBuildingBlock>();
A.CallTo(() => _simulation.UsedBuildingBlocks).Returns(new[] { _usedBB1, _usedBB2 });
_objectToLoad = _simulation;
_objectToLoad.IsLoaded = false;
}
public override void Execute(IExecutionContext context)
{
Add(new SetUsedBuildingBlockVersionCommand(_simulation, _usedBuildingBlock, _templateBuildingBlock.Version, context));
Add(new SetUsedBuildingBlockAlteredFlagCommand(_simulation, _usedBuildingBlock, false, context));
base.Execute(context);
_simulation = null;
_usedBuildingBlock = null;
_templateBuildingBlock = null;
}
protected override void Context()
{
_simulation = A.Fake <Simulation>();
_usedBuildingBlock = A.Fake <UsedBuildingBlock>();
_version = 3;
_context = A.Fake <IExecutionContext>();
_buildingBlockInProjectManager = A.Fake <IBuildingBlockInProjectManager>();
A.CallTo(() => _context.Resolve <IBuildingBlockInProjectManager>()).Returns(_buildingBlockInProjectManager);
sut = new SetUsedBuildingBlockVersionCommand(_simulation, _usedBuildingBlock, _version, _context);
}
protected override void Context()
{
base.Context();
_expressionProfile = DomainHelperForSpecs.CreateExpressionProfile <IndividualEnzyme>();
_individual = DomainHelperForSpecs.CreateIndividual();
_individual.AddExpressionProfile(_expressionProfile);
_usedBuildingBlock = new UsedBuildingBlock(_expressionProfile.Id, _expressionProfile.BuildingBlockType);
_simulation1.AddUsedBuildingBlock(_usedBuildingBlock);
A.CallTo(() => _buildingBlockRepository.All(A <Func <ISimulationSubject, bool> > ._))
.Returns(new[] { _individual });
}
public ApplicationIcon IconFor(UsedBuildingBlock usedBuildingBlock)
{
var iconName = usedBuildingBlock.BuildingBlockType.ToString();
if (usedBuildingBlock.BuildingBlockType == PKSimBuildingBlockType.Individual)
{
iconName = speciesNameFrom(usedBuildingBlock);
}
return(retrieveIconForStatus(iconName, _buildingBlockInSimulationManager.StatusFor(usedBuildingBlock)));
}
public UpdateUsedBuildingBlockInfoCommand(Simulation simulation, UsedBuildingBlock usedBuildingBlock, IPKSimBuildingBlock templateBuildingBlock, IExecutionContext context)
{
_simulation = simulation;
_usedBuildingBlock = usedBuildingBlock;
_templateBuildingBlock = templateBuildingBlock;
ObjectType = PKSimConstants.ObjectTypes.Simulation;
CommandType = PKSimConstants.Command.CommandTypeUpdate;
Description = PKSimConstants.Command.UpdateBuildingBlockInfoCommandDescription;
context.UpdateBuildingBlockPropertiesInCommand(this, _simulation);
Visible = false;
}
protected override void Context()
{
base.Context();
_originalSimulation = A.Fake <Simulation>();
_bb1 = new UsedBuildingBlock("Id1", PKSimBuildingBlockType.Individual);
_bb2 = new UsedBuildingBlock("Id2", PKSimBuildingBlockType.Compound);
_bb3 = new UsedBuildingBlock("Id3", PKSimBuildingBlockType.Event);
A.CallTo(() => _originalSimulation.Properties).Returns(new SimulationProperties());
A.CallTo(() => _originalSimulation.OutputSchema).Returns(new OutputSchema());
A.CallTo(() => _originalSimulation.UsedBuildingBlocks).Returns(new[] { _bb1, _bb2, _bb3 });
}
protected override void Context()
{
base.Context();
_bbIndTemplate = new UsedBuildingBlock("individual", PKSimBuildingBlockType.Individual);
_bbIndTemplate.Version = 10;
_bbIndTemplate.StructureVersion = 15;
_bbId1 = new UsedBuildingBlock("individual", PKSimBuildingBlockType.Individual)
{
BuildingBlock = A.Fake <Individual>()
};
}
protected override void Context()
{
_buildingBlock = A.Fake <IPKSimBuildingBlock>();
_buildingBlock.Id = "tralala";
_simulation = A.Fake <Simulation>();
_usedBuildingBlock = new UsedBuildingBlock("Template", PKSimBuildingBlockType.Compound);
_usedBuildingBlock.Id = "toto";
_simulation.Id = "trialai";
A.CallTo(() => _simulation.UsedBuildingBlockById(_usedBuildingBlock.Id)).Returns(_usedBuildingBlock);
sut = new UsedBuildingBlockInSimulationNode(_simulation, _usedBuildingBlock, _buildingBlock);
}
protected override void Context()
{
base.Context();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_cloneBuildingBlock = A.Fake <IPKSimBuildingBlock>();
A.CallTo(() => _templateBuildingBlock.Id).Returns("Id");
A.CallTo(() => _templateBuildingBlock.Version).Returns(5);
A.CallTo(() => _templateBuildingBlock.StructureVersion).Returns(8);
A.CallTo(() => _buildingBlockRepository.All()).Returns(new[] { _templateBuildingBlock, });
A.CallTo(() => _cloneManager.Clone(_templateBuildingBlock)).Returns(_cloneBuildingBlock);
_oldUsedBuildingBlock = null;
}
protected override void Context()
{
base.Context();
_templateSimulation = new IndividualSimulation();
_templateSimulation.Properties = new SimulationProperties();
_templateSimulation.ModelProperties = new ModelProperties();
_templateSimulation.AddUsedBuildingBlock(new UsedBuildingBlock("templateId3", PKSimBuildingBlockType.Individual)
{
BuildingBlock = new Individual()
});
var theCompound = new Compound {
Name = "theCompound"
};
_originalCalculationMethod = new CalculationMethod();
var usedBuildingBlock = new UsedBuildingBlock("templateID", PKSimBuildingBlockType.Compound)
{
BuildingBlock = theCompound
};
var theOtherCompound = new Compound {
Name = "theOtherCompound"
};
var anotherUsedBuildingBlock = new UsedBuildingBlock("templateID2", PKSimBuildingBlockType.Compound)
{
BuildingBlock = theOtherCompound
};
_templateSimulation.AddUsedBuildingBlock(usedBuildingBlock);
_templateSimulation.AddUsedBuildingBlock(anotherUsedBuildingBlock);
_replacementCalculationMethod = new CalculationMethod();
_newCalculationMethods = new List <CalculationMethodWithCompoundName> {
new CalculationMethodWithCompoundName(_replacementCalculationMethod, "theCompound")
};
var compoundProperties = new CompoundProperties {
Compound = theCompound
};
compoundProperties.CalculationMethodCache.AddCalculationMethod(_originalCalculationMethod);
_templateSimulation.Properties.AddCompoundProperties(compoundProperties);
compoundProperties = new CompoundProperties {
Compound = theOtherCompound
};
compoundProperties.CalculationMethodCache.AddCalculationMethod(_originalCalculationMethod);
_templateSimulation.Properties.AddCompoundProperties(compoundProperties);
A.CallTo(() => _cloner.Clone(_templateSimulation)).Returns(_templateSimulation);
A.CallTo(() => _objectBaseFactory.Create <IndividualSimulation>()).ReturnsLazily(() => new IndividualSimulation());
}
protected override void Context()
{
base.Context();
_templateFormulation = new Formulation().WithId("f1");
_localFormulation = new Formulation().WithId("f2");
var usedBuildingBlock = new UsedBuildingBlock("f1", PKSimBuildingBlockType.Formulation)
{
BuildingBlock = _localFormulation
};
_simulation.AddUsedBuildingBlock(usedBuildingBlock);
A.CallTo(() => _buildingBlockInSmulationManager.TemplateBuildingBlockUsedBy <Formulation>(usedBuildingBlock)).Returns(_localFormulation);
}
protected override void Context()
{
base.Context();
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_templateBuildingBlock.Id = "toto";
_simulation = A.Fake <Simulation>();
_oldUsedBuildingBlock = A.Fake <UsedBuildingBlock>();
_newUsedBuildingBlock = A.Fake <UsedBuildingBlock>();
_newUsedBuildingBlock.Id = "tralala";
A.CallTo(() => _newUsedBuildingBlock.TemplateId).Returns(_templateBuildingBlock.Id);
A.CallTo(() => _simulation.UsedBuildingBlockInSimulation(PKSimBuildingBlockType.SimulationSubject)).Returns(_oldUsedBuildingBlock);
A.CallTo(() => _buildingBlockMapper.MapFrom(_templateBuildingBlock, _oldUsedBuildingBlock)).Returns(_newUsedBuildingBlock);
}
private UsedBuildingBlockMetaData mapFrom(UsedBuildingBlock usedBuildingBlock)
{
return(new UsedBuildingBlockMetaData
{
Id = usedBuildingBlock.Id,
Name = usedBuildingBlock.Name,
TemplateId = usedBuildingBlock.TemplateId,
Version = usedBuildingBlock.Version,
BuildingBlockType = usedBuildingBlock.BuildingBlockType,
StructureVersion = usedBuildingBlock.StructureVersion,
Altered = usedBuildingBlock.Altered,
});
}
public IPKSimBuildingBlock TemplateBuildingBlockUsedBy(UsedBuildingBlock usedBuildingBlock)
{
if (usedBuildingBlock == null)
{
return(null);
}
if (StatusFor(usedBuildingBlock) == BuildingBlockStatus.Red)
{
return(usedBuildingBlock.BuildingBlock);
}
return(_buildingBlockRepository.ById(usedBuildingBlock.TemplateId));
}
protected override void Context()
{
_eventPublisher = A.Fake <IEventPublisher>();
_buildingBlockRepository = A.Fake <IBuildingBlockRepository>();
_simulation1 = new IndividualSimulation();
_simulation2 = new IndividualSimulation();
_simulation3 = new IndividualSimulation();
A.CallTo(() => _buildingBlockRepository.All <Simulation>()).Returns(new[] { _simulation1, _simulation2, _simulation3 });
_id = "tralala";
_templateBuildingBlock = A.Fake <IPKSimBuildingBlock>().WithId(_id);
_usedBuildingBlock = new UsedBuildingBlock(_templateBuildingBlock.Id, _templateBuildingBlock.BuildingBlockType);
A.CallTo(() => _buildingBlockRepository.ById(_templateBuildingBlock.Id)).Returns(_templateBuildingBlock);
sut = new BuildingBlockInProjectManager(_buildingBlockRepository, _eventPublisher);
}
protected override void Context()
{
_simulation = A.Fake <Simulation>();
_buildingBlock = A.Fake <IPKSimBuildingBlock>();
_context = A.Fake <IExecutionContext>();
_usedBuildingBlock = A.Fake <UsedBuildingBlock>();
_buildingBlockInProjectManager = A.Fake <IBuildingBlockInProjectManager>();
_buildingBlockId = "toto";
A.CallTo(() => _simulation.UsedBuildingBlockById(_buildingBlockId)).Returns(_usedBuildingBlock);
_buildingBlock.Id = _buildingBlockId;
_altered = false;
A.CallTo(() => _simulation.GetAltered(_buildingBlockId)).Returns(true);
A.CallTo(() => _context.Resolve <IBuildingBlockInProjectManager>()).Returns(_buildingBlockInProjectManager);
sut = new SetUsedBuildingBlockAlteredFlagCommand(_simulation, _usedBuildingBlock, _altered, _context);
}
protected override void Context()
{
base.Context();
_bb1 = A.Fake <IPKSimBuildingBlock>();
_bb2 = A.Fake <IPKSimBuildingBlock>();
_bb1.Id = "Tralala";
_bb2.Id = "trilil";
_usedBuildingBlock1 = new UsedBuildingBlock(_bb1.Id, _bb1.BuildingBlockType);
_usedBuildingBlock2 = new UsedBuildingBlock(_bb2.Id, _bb2.BuildingBlockType);
_simulation1.AddUsedBuildingBlock(_usedBuildingBlock1);
_simulation2.AddUsedBuildingBlock(_usedBuildingBlock2);
_simulation3.AddUsedBuildingBlock(_usedBuildingBlock1);
_simulation3.AddUsedBuildingBlock(_usedBuildingBlock2);
}
public SetUsedBuildingBlockVersionCommand(Simulation simulation, UsedBuildingBlock usedBuildingBlock, int version, IExecutionContext context)
{
_simulation = simulation;
_usedBuildingBlock = usedBuildingBlock;
_simulationId = simulation.Id;
_usedBuildingBlockId = usedBuildingBlock.Id;
_version = version;
IPKSimBuildingBlock buildingBlock = usedBuildingBlock.BuildingBlock;
Visible = false;
ObjectType = PKSimConstants.ObjectTypes.Simulation;
CommandType = PKSimConstants.Command.CommandTypeEdit;
Description = string.Format(PKSimConstants.Command.SetUsedBuildingBlockVersionCommandDescription,
context.TypeFor(buildingBlock), usedBuildingBlock.Name, _version, _simulation.Name);
context.UpdateBuildingBlockPropertiesInCommand(this, _simulation);
}
