protected TagFunction AddTagFunction(PreservationContext context, string tagFunctionCode, string registerCode)
{
var tf = new TagFunction(TestPlant, tagFunctionCode, "Description", registerCode);
context.TagFunctions.Add(tf);
context.SaveChangesAsync().Wait();
return(tf);
}
public void Setup()
{
// Arrange
_rtRepositoryMock = new Mock <IRequirementTypeRepository>();
var rdMock1 = new Mock <RequirementDefinition>();
rdMock1.SetupGet(x => x.Id).Returns(ReqDefId1);
rdMock1.SetupGet(x => x.Plant).Returns(TestPlant);
_reqDef1 = rdMock1.Object;
var rdMock2 = new Mock <RequirementDefinition>();
rdMock2.SetupGet(x => x.Id).Returns(ReqDefId2);
rdMock2.SetupGet(x => x.Plant).Returns(TestPlant);
_reqDef2 = rdMock2.Object;
_rtRepositoryMock
.Setup(r => r.GetRequirementDefinitionsByIdsAsync(new List <int> {
ReqDefId1, ReqDefId2
}))
.Returns(Task.FromResult(new List <RequirementDefinition> {
rdMock1.Object, rdMock2.Object
}));
_tagFunctionApiServiceMock = new Mock <ITagFunctionApiService>();
_tagFunctionApiServiceMock.Setup(t => t.TryGetTagFunctionAsync(TestPlant, TagFunctionCode, RegisterCode))
.Returns(Task.FromResult(new PCSTagFunction
{
Code = TagFunctionCode,
Description = PCSDescription,
RegisterCode = RegisterCode
}));
_commandWithTwoRequirements = new UpdateRequirementsCommand(TagFunctionCode, RegisterCode,
new List <RequirementForCommand>
{
new RequirementForCommand(ReqDefId1, Interval1),
new RequirementForCommand(ReqDefId2, Interval2),
});
_commandWithoutRequirements = new UpdateRequirementsCommand(TagFunctionCode, RegisterCode, null);
_tfRepositoryMock = new Mock <ITagFunctionRepository>();
_tfRepositoryMock
.Setup(x => x.Add(It.IsAny <TagFunction>()))
.Callback <TagFunction>(tf =>
{
_tfAddedToRepository = tf;
});
_dut = new UpdateRequirementsCommandHandler(
_tfRepositoryMock.Object,
_rtRepositoryMock.Object,
UnitOfWorkMock.Object,
PlantProviderMock.Object,
_tagFunctionApiServiceMock.Object);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_tfWithRequirement = AddTagFunction(context, "TFC2", "RC1");
var rt = AddRequirementTypeWith1DefWithoutField(context, "ROT", "R", RequirementTypeIcon.Other);
_requirementDefinition = rt.RequirementDefinitions.First();
_tfWithRequirement.AddRequirement(new TagFunctionRequirement(TestPlant, 4, _requirementDefinition));
_tfWithoutRequirement = AddTagFunction(context, "TFC1", "RC1");
context.SaveChangesAsync().Wait();
}
}
private async Task <TagFunction> CreateNewTagFunctionAsync(string tagFunctionCode, string registerCode)
{
var pcsTagFunction = await _tagFunctionApiService.TryGetTagFunctionAsync(_plantProvider.Plant, tagFunctionCode, registerCode);
if (pcsTagFunction == null)
{
return(null);
}
var tagFunction = new TagFunction(_plantProvider.Plant, tagFunctionCode, pcsTagFunction.Description, registerCode);
_tagFunctionRepository.Add(tagFunction);
return(tagFunction);
}
public async Task SaveTestAsync()
{
// given
var tagServiceMock = new TagServiceMock();
var tagGroupServiceMock = new TagGroupServiceMock();
TagFunction.TagService = table => tagServiceMock;
TagFunction.TagGroupService = table => tagGroupServiceMock;
// when
Func <Task> action = () => TagFunction.SaveAsync(new TagDto(), null, null, null);
// then
await Assert.ThrowsAsync <ArgumentException>(action);
}
private async Task AddRequirementsToTagFunctionAsync(TagFunction tagFunction, IList <RequirementForCommand> requirements)
{
var reqDefIds = requirements.Select(r => r.RequirementDefinitionId).ToList();
var reqDefs = await _requirementTypeRepository.GetRequirementDefinitionsByIdsAsync(reqDefIds);
foreach (var requirement in requirements)
{
if (tagFunction.Requirements.All(r => r.RequirementDefinitionId != requirement.RequirementDefinitionId))
{
var reqDef = reqDefs.Single(rd => rd.Id == requirement.RequirementDefinitionId);
tagFunction.AddRequirement(new TagFunctionRequirement(_plantProvider.Plant, requirement.IntervalWeeks, reqDef));
}
}
}
public async Task HandlingUpdateRequirementsCommand_ShouldNotAddAnyTagFunctionToRepository_WhenTagFunctionAlreadyExists()
{
// Arrange
var tagFunction = new TagFunction(TestPlant, TagFunctionCode, "", RegisterCode);
_tfRepositoryMock
.Setup(r => r.GetByCodesAsync(TagFunctionCode, RegisterCode)).Returns(Task.FromResult(tagFunction));
// Act
var result = await _dut.Handle(_commandWithTwoRequirements, default);
// Assert
Assert.AreEqual(0, result.Errors.Count);
Assert.IsNull(_tfAddedToRepository);
}
private async Task CloneTagFunctions(string sourcePlant, string targetPlant)
{
var originalPlant = _plantProvider.Plant;
_plantSetter.SetPlant(sourcePlant);
var sourceTagFunctions = await _tagFunctionRepository.GetAllAsync();
var sourceRTs = await _requirementTypeRepository.GetAllAsync();
var sourceRDs = sourceRTs.SelectMany(rt => rt.RequirementDefinitions).ToList();
_plantSetter.SetPlant(originalPlant);
var targetTagFunctions = await _tagFunctionRepository.GetAllAsync();
var targetRTs = await _requirementTypeRepository.GetAllAsync();
var targetRDs = targetRTs.SelectMany(rt => rt.RequirementDefinitions).ToList();
foreach (var sourceTagFunction in sourceTagFunctions)
{
var mainTagFunction = await _tagFunctionApiService.TryGetTagFunctionAsync(
targetPlant,
sourceTagFunction.Code,
sourceTagFunction.RegisterCode);
if (mainTagFunction == null)
{
continue;
}
var targetTagFunction = targetTagFunctions.SingleOrDefault(
t => t.Code == sourceTagFunction.Code && t.RegisterCode == sourceTagFunction.RegisterCode);
if (targetTagFunction == null)
{
targetTagFunction = new TagFunction(
targetPlant,
sourceTagFunction.Code,
sourceTagFunction.Description,
sourceTagFunction.RegisterCode);
_tagFunctionRepository.Add(targetTagFunction);
}
CloneRequirements(sourceRDs, sourceTagFunction, targetRDs, targetTagFunction);
}
}
private void CloneRequirements(
List <RequirementDefinition> sourceRDs,
TagFunction sourceTagFunction,
List <RequirementDefinition> targetRDs,
TagFunction targetTagFunction)
{
foreach (var sourceRequirement in sourceTagFunction.Requirements)
{
var sourceRD = sourceRDs.Single(s => s.Id == sourceRequirement.RequirementDefinitionId);
var targetRD = targetRDs.Single(t => t.Title == sourceRD.Title);
if (targetTagFunction.Requirements.SingleOrDefault(r => r.RequirementDefinitionId == targetRD.Id) == null)
{
var targetRequirement = new TagFunctionRequirement(targetTagFunction.Plant, sourceRequirement.IntervalWeeks, targetRD);
targetTagFunction.AddRequirement(targetRequirement);
}
}
}
public async Task HandlingUpdateRequirementsCommand_ShouldAddNewRequirementsToExistingTagFunction()
{
// Arrange
var tagFunction = new TagFunction(TestPlant, TagFunctionCode, "", RegisterCode);
Assert.AreEqual(0, tagFunction.Requirements.Count);
_tfRepositoryMock
.Setup(r => r.GetByCodesAsync(TagFunctionCode, RegisterCode)).Returns(Task.FromResult(tagFunction));
// Act
await _dut.Handle(_commandWithTwoRequirements, default);
// Assert
Assert.AreEqual(2, tagFunction.Requirements.Count);
AssertRequirement(tagFunction.Requirements, ReqDefId1, Interval1);
AssertRequirement(tagFunction.Requirements, ReqDefId2, Interval2);
}
public void Setup()
{
// Arrange
var tagFunctionRepositoryMock = new Mock <ITagFunctionRepository>();
const string TagFunctionCode = "TFC";
const string RegisterCode = "RC";
_tagFunction = new TagFunction(TestPlant, "ReqDefinitionTitle", "TagFunctionDescription", "MAIN_EQUIP");
tagFunctionRepositoryMock.Setup(r => r.GetByCodesAsync(TagFunctionCode, RegisterCode))
.Returns(Task.FromResult(_tagFunction));
_command = new VoidTagFunctionCommand(TagFunctionCode, RegisterCode, _rowVersion);
_dut = new VoidTagFunctionCommandHandler(
tagFunctionRepositoryMock.Object,
UnitOfWorkMock.Object);
}
public void Setup()
{
var rdMock1 = new Mock <RequirementDefinition>();
rdMock1.SetupGet(r => r.Id).Returns(1);
rdMock1.SetupGet(r => r.Plant).Returns(TestPlant);
var rdMock2 = new Mock <RequirementDefinition>();
rdMock2.SetupGet(r => r.Id).Returns(2);
rdMock2.SetupGet(r => r.Plant).Returns(TestPlant);
var rdMock3 = new Mock <RequirementDefinition>();
rdMock3.SetupGet(r => r.Id).Returns(3);
rdMock3.SetupGet(r => r.Plant).Returns(TestPlant);
_tfWithoutReq = new TagFunction(TestPlant, _tfWithoutReqCode, _tfWithoutReqDesc, _registerCode);
_tfWithoutReq.SetProtectedIdForTesting(_tfWithoutReqId);
_tf1WithReq = new TagFunction(TestPlant, _tf1WithReqCode, _tf1WithReqDesc, _registerCode);
_tf1WithReq.SetProtectedIdForTesting(_tf1WithReqId);
_tf2WithReq = new TagFunction(TestPlant, _tf2WithReqCode, _tf2WithReqDesc, _registerCode);
_tf2WithReq.SetProtectedIdForTesting(_tf2WithReqId);
_tfReq1_1 = new TagFunctionRequirement(TestPlant, 1, rdMock1.Object);
_tfReq1_1.SetProtectedIdForTesting(_tfReq1_1Id);
_tfReq1_2 = new TagFunctionRequirement(TestPlant, 1, rdMock2.Object);
_tfReq1_2.SetProtectedIdForTesting(_tfReq1_2Id);
_tf1WithReq.AddRequirement(_tfReq1_1);
_tf1WithReq.AddRequirement(_tfReq1_2);
_tfReq2_1 = new TagFunctionRequirement(TestPlant, 1, rdMock3.Object);
_tf2WithReq.AddRequirement(_tfReq2_1);
var tagFunctions = new List <TagFunction> {
_tfWithoutReq, _tf1WithReq, _tf2WithReq
};
var dbSetMock = tagFunctions.AsQueryable().BuildMockDbSet();
ContextHelper
.ContextMock
.Setup(x => x.TagFunctions)
.Returns(dbSetMock.Object);
_dut = new TagFunctionRepository(ContextHelper.ContextMock.Object);
}
private void RemoveChangedOrRemovedRequirementsFromTagFunction(TagFunction tagFunction, IList <RequirementForCommand> updatedRequirements)
{
var tagFunctionRequirements = tagFunction.Requirements;
var requirementsToBeRemoved = new List <TagFunctionRequirement>();
foreach (var existingRequirement in tagFunctionRequirements)
{
var updatedRequirement = updatedRequirements.FirstOrDefault(r =>
r.RequirementDefinitionId == existingRequirement.RequirementDefinitionId);
if (updatedRequirement == null || existingRequirement.IntervalWeeks != updatedRequirement.IntervalWeeks)
{
requirementsToBeRemoved.Add(existingRequirement);
}
}
requirementsToBeRemoved.ForEach(tagFunction.RemoveRequirement);
}
private Tag CreateTag(
AutoScopeTagsCommand request,
Step step,
PCSTagDetails tagDetails,
TagFunction tagFunctionWithRequirements,
IList <RequirementDefinition> reqDefs)
{
var requirements = new List <TagRequirement>();
foreach (var requirement in tagFunctionWithRequirements.Requirements.Where(r => !r.IsVoided))
{
var reqDef = reqDefs.Single(rd => rd.Id == requirement.RequirementDefinitionId);
requirements.Add(new TagRequirement(_plantProvider.Plant, requirement.IntervalWeeks, reqDef));
}
var tag = new Tag(
_plantProvider.Plant,
TagType.Standard,
tagDetails.TagNo,
tagDetails.Description,
step,
requirements)
{
Calloff = tagDetails.CallOffNo,
CommPkgNo = tagDetails.CommPkgNo,
McPkgNo = tagDetails.McPkgNo,
PurchaseOrderNo = tagDetails.PurchaseOrderNo,
Remark = request.Remark,
StorageArea = request.StorageArea,
TagFunctionCode = tagDetails.TagFunctionCode
};
tag.SetArea(tagDetails.AreaCode, tagDetails.AreaDescription);
tag.SetDiscipline(tagDetails.DisciplineCode, tagDetails.DisciplineDescription);
return(tag);
}
public void Setup()
{
_plantSetter = new Mock <IPlantSetter>();
_unitOfWork = new Mock <IUnitOfWork>();
_telemetryClient = new Mock <ITelemetryClient>();
_responsibleRepository = new Mock <IResponsibleRepository>();
_projectRepository = new Mock <IProjectRepository>();
_tagFunctionRepository = new Mock <ITagFunctionRepository>();
// Assert tags in preservation
var rdMock = new Mock <RequirementDefinition>();
rdMock.SetupGet(rd => rd.Plant).Returns(Plant);
var stepMock = new Mock <Step>();
stepMock.SetupGet(s => s.Plant).Returns(Plant);
_tag1 = new Tag(Plant, TagType.Standard, TagNo1, OldTagDescription1, stepMock.Object, new List <TagRequirement>
{
new TagRequirement(Plant, 4, rdMock.Object)
});
_tag1.McPkgNo = McPkg1;
_tag1.CommPkgNo = CommPkg1;
_tag2 = new Tag(Plant, TagType.Standard, TagNo2, OldTagDescription2, stepMock.Object, new List <TagRequirement>
{
new TagRequirement(Plant, 4, rdMock.Object)
});
_tag2.McPkgNo = McPkg2;
_tag2.CommPkgNo = CommPkg2;
var tags = new List <Tag>
{
_tag1, _tag2
};
_responsible = new Responsible(Plant, Code, Description);
_responsibleRepository.Setup(r => r.GetByCodeAsync(Code)).Returns(Task.FromResult(_responsible));
_project1 = new Project(Plant, Project1Name, Project1Description);
_project1.AddTag(_tag1);
_project1.AddTag(_tag2);
_projectRepository.Setup(p => p.GetStandardTagsInProjectOnlyAsync(Project1Name))
.Returns(Task.FromResult(tags));
_projectRepository.Setup(p => p.GetProjectWithTagsByNameAsync(Project1Name))
.Returns(Task.FromResult(_project1));
_projectRepository.Setup(p => p.GetProjectOnlyByNameAsync(Project1Name))
.Returns(Task.FromResult(_project1));
_project2 = new Project(Plant, Project2Name, Project2Description);
_projectRepository.Setup(p => p.GetProjectWithTagsByNameAsync(Project2Name))
.Returns(Task.FromResult(_project2));
_projectRepository.Setup(p => p.GetProjectOnlyByNameAsync(Project2Name))
.Returns(Task.FromResult(_project2));
_projectRepository.Setup(p => p.Add(It.IsAny <Project>())).Callback((Project p) => _newProjectCreated = p);
_tagFunction = new TagFunction(Plant, TagFunctionCode, TagFunctionDescription, RegisterCode);
_tagFunctionRepository.Setup(t => t.GetByCodesAsync(TagFunctionCode, RegisterCode))
.Returns(Task.FromResult(_tagFunction));
var synchronizationOptions = new Mock <IOptionsMonitor <SynchronizationOptions> >();
synchronizationOptions.Setup(s => s.CurrentValue).Returns(new SynchronizationOptions {
UserOid = Guid.NewGuid()
});
var currentUserSetter = new Mock <ICurrentUserSetter>();
var claimsProvider = new Mock <IClaimsProvider>();
claimsProvider.Setup(c => c.GetCurrentUser()).Returns(new ClaimsPrincipal());
var projectApiService = new Mock <IProjectApiService>();
projectApiService.Setup(p => p.TryGetProjectAsync(Plant, _projectNotInPreservation)).Returns(Task.FromResult(new PCSProject {
Description = "Project Description", IsClosed = false, Name = _projectNotInPreservation
}));
_dut = new BusReceiverService(_plantSetter.Object,
_unitOfWork.Object,
_telemetryClient.Object,
_responsibleRepository.Object,
_projectRepository.Object,
_tagFunctionRepository.Object,
currentUserSetter.Object,
claimsProvider.Object,
new Mock <IBearerTokenSetter>().Object,
new Mock <IApplicationAuthenticator>().Object,
synchronizationOptions.Object,
projectApiService.Object);
}
private string Key(TagFunction tagFunction) => $"{tagFunction.Code}|{tagFunction.RegisterCode}";
public void Setup()
{
// Arrange
var tagFunctionCode1 = "TagFunctionCode1";
var registerCode1 = "RegisterCodeCode1";
var tagFunctionCode2 = "TagFunctionCode2";
var registerCode2 = "RegisterCodeCode2";
_modeRepositoryMock = new Mock <IModeRepository>();
_modeMock = new Mock <Mode>();
_modeMock.SetupGet(m => m.Plant).Returns(TestPlant);
_modeMock.SetupGet(x => x.Id).Returns(ModeId);
_modeRepositoryMock
.Setup(r => r.GetByIdAsync(ModeId))
.Returns(Task.FromResult(_modeMock.Object));
// Arrange
step = new Step(TestPlant, "S", _modeMock.Object, new Responsible(TestPlant, "RC", "RD"));
step.SetProtectedIdForTesting(StepId);
_journeyRepositoryMock = new Mock <IJourneyRepository>();
_journeyRepositoryMock
.Setup(x => x.GetStepByStepIdAsync(StepId))
.Returns(Task.FromResult(step));
_projectRepositoryMock = new Mock <IProjectRepository>();
_projectRepositoryMock
.Setup(x => x.Add(It.IsAny <Project>()))
.Callback <Project>(project =>
{
_projectAddedToRepository = project;
});
_rtRepositoryMock = new Mock <IRequirementTypeRepository>();
var rdMock1 = new Mock <RequirementDefinition>();
rdMock1.SetupGet(x => x.Id).Returns(ReqDefId1);
rdMock1.SetupGet(x => x.Plant).Returns(TestPlant);
var rdMock2a = new Mock <RequirementDefinition>();
rdMock2a.SetupGet(x => x.Id).Returns(ReqDefId2a);
rdMock2a.SetupGet(x => x.Plant).Returns(TestPlant);
var rdMock2b = new Mock <RequirementDefinition>();
rdMock2b.SetupGet(x => x.Id).Returns(ReqDefId2b);
rdMock2b.SetupGet(x => x.Plant).Returns(TestPlant);
_rtRepositoryMock
.Setup(r => r.GetRequirementDefinitionsByIdsAsync(new List <int> {
ReqDefId1, ReqDefId2a
}))
.Returns(Task.FromResult(new List <RequirementDefinition> {
rdMock1.Object, rdMock2a.Object
}));
var tf1 = new TagFunction(TestPlant, tagFunctionCode1, "TF1", registerCode1);
tf1.AddRequirement(new TagFunctionRequirement(TestPlant, Interval1, rdMock1.Object));
var tf2 = new TagFunction(TestPlant, tagFunctionCode2, "TF2", registerCode2);
tf2.AddRequirement(new TagFunctionRequirement(TestPlant, Interval2, rdMock2a.Object));
var voidedTFRequirement = new TagFunctionRequirement(TestPlant, Interval2, rdMock2b.Object);
voidedTFRequirement.IsVoided = true;
tf2.AddRequirement(voidedTFRequirement);
var rdMock3 = new Mock <RequirementDefinition>();
rdMock3.SetupGet(x => x.Id).Returns(ReqDefId3);
rdMock3.SetupGet(x => x.Plant).Returns(TestPlant);
var tf3 = new TagFunction(TestPlant, "TagFunctionCode3", "TF3", "RegisterCodeCode3");
tf3.AddRequirement(new TagFunctionRequirement(TestPlant, Interval1, rdMock1.Object));
tf3.AddRequirement(new TagFunctionRequirement(TestPlant, Interval2, rdMock2a.Object));
tf3.AddRequirement(new TagFunctionRequirement(TestPlant, 3, rdMock3.Object));
_tfRepositoryMock = new Mock <ITagFunctionRepository>();
_tfRepositoryMock
.Setup(x => x.GetAllNonVoidedWithRequirementsAsync())
.Returns(Task.FromResult(new List <TagFunction> {
tf1, tf2, tf3
}));
_mainTagDetails1 = new PCSTagDetails
{
AreaCode = "AreaCode1",
AreaDescription = "AreaDescription1",
CallOffNo = "CalloffNo1",
CommPkgNo = "CommPkgNo1",
Description = "Description1",
DisciplineCode = "DisciplineCode1",
DisciplineDescription = "DisciplineDescription1",
McPkgNo = "McPkgNo1",
PurchaseOrderNo = "PurchaseOrderNo1",
TagFunctionCode = tagFunctionCode1,
RegisterCode = registerCode1,
TagNo = TestTagNo1,
ProjectDescription = TestProjectDescription
};
_mainTagDetails2 = new PCSTagDetails
{
AreaCode = "AreaCode2",
AreaDescription = "AreaDescription2",
CallOffNo = "CalloffNo2",
CommPkgNo = "CommPkgNo2",
Description = "Description2",
DisciplineCode = "DisciplineCode2",
DisciplineDescription = "DisciplineDescription1",
McPkgNo = "McPkgNo2",
PurchaseOrderNo = "PurchaseOrderNo2",
TagFunctionCode = tagFunctionCode2,
RegisterCode = registerCode2,
TagNo = TestTagNo2,
ProjectDescription = TestProjectDescription
};
IList <PCSTagDetails> mainTagDetailList = new List <PCSTagDetails> {
_mainTagDetails1, _mainTagDetails2
};
_tagApiServiceMock = new Mock <ITagApiService>();
_tagApiServiceMock
.Setup(x => x.GetTagDetailsAsync(TestPlant, TestProjectName, new List <string> {
TestTagNo1, TestTagNo2
}))
.Returns(Task.FromResult(mainTagDetailList));
_command = new AutoScopeTagsCommand(
new List <string> {
TestTagNo1, TestTagNo2
},
TestProjectName,
step.Id,
"Remark",
"SA");
_dut = new AutoScopeTagsCommandHandler(
_projectRepositoryMock.Object,
_journeyRepositoryMock.Object,
_modeRepositoryMock.Object,
_tfRepositoryMock.Object,
_rtRepositoryMock.Object,
UnitOfWorkMock.Object,
PlantProviderMock.Object,
_tagApiServiceMock.Object);
}
public void Setup()
{
var reqDefId = 0;
_modeRepository = new ModeRepository(_plantProvider, _sourceModes);
_sourceModes.Add(new Mode(_sourcePlant, "ModeA", false));
_sourceModes.Add(new Mode(_sourcePlant, "ModeB", false));
_requirementTypeRepository = new RequirementTypeRepository(_plantProvider, _sourceRequirementTypes);
var requirementTypeA = new RequirementType(_sourcePlant, "RequirementTypeCodeA", "RequirementTypeTitleA", _requirementIconOther, 1);
var reqDefA1 = new RequirementDefinition(_sourcePlant, "RequirementDefCodeA1", 1, RequirementUsage.ForAll, 2);
reqDefA1.SetProtectedIdForTesting(++reqDefId);
requirementTypeA.AddRequirementDefinition(reqDefA1);
var reqDefA2 = new RequirementDefinition(_sourcePlant, "RequirementDefCodeA2", 3, RequirementUsage.ForAll, 4);
reqDefA2.SetProtectedIdForTesting(++reqDefId);
requirementTypeA.AddRequirementDefinition(reqDefA2);
reqDefA1.AddField(new Field(_sourcePlant, "LabelA", FieldType.Number, 1, "UnitA", true));
var requirementTypeB = new RequirementType(_sourcePlant, "RequirementTypeCodeB", "RequirementTypeTitleB", _requirementIconOther, 2);
_sourceRequirementTypes.Add(requirementTypeA);
_sourceRequirementTypes.Add(requirementTypeB);
_tagFunctionRepository = new TagFunctionRepository(_plantProvider, _sourceTagFunctions);
var tagFunctionA = new TagFunction(_sourcePlant, _tfCodeA, "TagFunctionDescA", _regCodeA);
tagFunctionA.AddRequirement(new TagFunctionRequirement(_sourcePlant, 1, reqDefA1));
tagFunctionA.AddRequirement(new TagFunctionRequirement(_sourcePlant, 2, reqDefA2));
var tagFunctionB = new TagFunction(_sourcePlant, _tfCodeB, "TagFunctionDescB", _regCodeB);
_sourceTagFunctions.Add(tagFunctionA);
_sourceTagFunctions.Add(tagFunctionB);
_tagFunctionApiServiceMock = new Mock <ITagFunctionApiService>();
_tagFunctionApiServiceMock
.Setup(t => t.TryGetTagFunctionAsync(TestPlant, _tfCodeA, _regCodeA))
.Returns(Task.FromResult(new PCSTagFunction
{
Code = _tfCodeA, RegisterCode = _regCodeA
}));
_tagFunctionApiServiceMock
.Setup(t => t.TryGetTagFunctionAsync(TestPlant, _tfCodeB, _regCodeB))
.Returns(Task.FromResult(new PCSTagFunction
{
Code = _tfCodeB, RegisterCode = _regCodeB
}));
_command = new CloneCommand(_sourcePlant, TestPlant);
_dut = new CloneCommandHandler(
_plantProvider,
_plantProvider,
UnitOfWorkMock.Object,
_modeRepository,
_requirementTypeRepository,
_tagFunctionRepository,
_tagFunctionApiServiceMock.Object);
UnitOfWorkMock
.Setup(uiw => uiw.SaveChangesAsync(It.IsAny <CancellationToken>()))
.Callback(() =>
{
// Need this to simulate what EF Core do with Ids upon saving new Items
_requirementTypeRepository.Save();
});
}
