protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_requirementTypeWithoutDefinition = new RequirementType(TestPlant, "T", "Title", RequirementTypeIcon.Area, 1);
context.RequirementTypes.Add(_requirementTypeWithoutDefinition);
context.SaveChangesAsync().Wait();
_requirementType = AddRequirementTypeWith1DefWithoutField(context, "T0", "D0", RequirementTypeIcon.Other, 999);
_requirementDefWithoutField = _requirementType.RequirementDefinitions.Single();
_requirementDefWithInfo = new RequirementDefinition(TestPlant, "D1", 2, RequirementUsage.ForAll, 1);
_requirementType.AddRequirementDefinition(_requirementDefWithInfo);
_requirementDefWithNumber = new RequirementDefinition(TestPlant, "D2", 2, RequirementUsage.ForAll, 1);
_requirementType.AddRequirementDefinition(_requirementDefWithNumber);
_requirementDefWithCheckbox = new RequirementDefinition(TestPlant, "D3", 2, RequirementUsage.ForAll, 1);
_requirementType.AddRequirementDefinition(_requirementDefWithCheckbox);
_requirementDefWithAttachment = new RequirementDefinition(TestPlant, "D4", 2, RequirementUsage.ForAll, 1);
_requirementType.AddRequirementDefinition(_requirementDefWithAttachment);
context.SaveChangesAsync().Wait();
_infoField = AddInfoField(context, _requirementDefWithInfo, "LabelA");
_numberField = AddNumberField(context, _requirementDefWithNumber, "LabelB", "UnitA", true);
_checkboxField = AddCheckBoxField(context, _requirementDefWithCheckbox, "LabelC");
_attachmentField = AddAttachmentField(context, _requirementDefWithAttachment, "LabelD");
}
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_reqType1 = AddRequirementTypeWith1DefWithoutField(context, "T1", "D1", _reqIconOther, 999);
_reqDefForAll = _reqType1.RequirementDefinitions.First();
_reqDefVoided = new RequirementDefinition(TestPlant, "D2", 2, RequirementUsage.ForAll, 2);
_reqDefVoided.IsVoided = true;
_reqDefForOther = new RequirementDefinition(TestPlant, "D3", 2, RequirementUsage.ForOtherThanSuppliers, 3);
_reqDefForSupplier = new RequirementDefinition(TestPlant, "D4", 2, RequirementUsage.ForSuppliersOnly, 4);
_reqType1.AddRequirementDefinition(_reqDefVoided);
_reqType1.AddRequirementDefinition(_reqDefForOther);
_reqType1.AddRequirementDefinition(_reqDefForSupplier);
context.SaveChangesAsync().Wait();
AddNumberField(context, _reqDefForAll, _numberLabel, _numberUnit, true);
var f = AddNumberField(context, _reqDefForAll, "NUMBER", "mm", true);
f.IsVoided = true;
context.SaveChangesAsync().Wait();
var reqType2 = AddRequirementTypeWith1DefWithoutField(context, "T2", "D2", _reqIconOther, 7);
reqType2.IsVoided = true;
context.SaveChangesAsync().Wait();
AddRequirementTypeWith1DefWithoutField(context, "T3", "D3", _reqIconOther, 10000);
AddRequirementTypeWith1DefWithoutField(context, "T4", "D4", _reqIconOther, 1);
}
}
public void Setup()
{
_field = new Field(TestPlant, "L", FieldType.Info, 1);
_rd1 = new RequirementDefinition(TestPlant, "RD1", 1, RequirementUsage.ForAll, 1);
_rd1.SetProtectedIdForTesting(_reqDefId);
_rd1.AddField(_field);
var rd2 = new RequirementDefinition(TestPlant, "RD2", 1, RequirementUsage.ForAll, 2);
var rd3 = new RequirementDefinition(TestPlant, "RD3", 1, RequirementUsage.ForAll, 3);
var requirementType = new RequirementType(TestPlant, "C1", "T1", _reqIconOther, 0);
requirementType.AddRequirementDefinition(_rd1);
requirementType.AddRequirementDefinition(rd2);
requirementType.AddRequirementDefinition(rd3);
_requirementTypes = new List <RequirementType>
{
requirementType,
new RequirementType(TestPlant, "C2", "T2", _reqIconOther, 0),
new RequirementType(TestPlant, "C3", "T3", _reqIconOther, 0)
};
_rtSetMock = _requirementTypes.AsQueryable().BuildMockDbSet();
ContextHelper
.ContextMock
.Setup(x => x.RequirementTypes)
.Returns(_rtSetMock.Object);
var requirementDefinitions = new List <RequirementDefinition>
{
_rd1, rd2, rd3
};
_rdSetMock = requirementDefinitions.AsQueryable().BuildMockDbSet();
ContextHelper
.ContextMock
.Setup(x => x.RequirementDefinitions)
.Returns(_rdSetMock.Object);
var fields = new List <Field>
{
_field
};
_fieldSetMock = fields.AsQueryable().BuildMockDbSet();
ContextHelper
.ContextMock
.Setup(x => x.Fields)
.Returns(_fieldSetMock.Object);
_dut = new RequirementTypeRepository(ContextHelper.ContextMock.Object);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
_requirementType = AddRequirementTypeWith1DefWithoutField(context, "R", "D1", RequirementTypeIcon.Other);
_reqDefForAll = _reqDefWithoutField = _requirementType.RequirementDefinitions.First();
_reqDefForSupplier = new RequirementDefinition(TestPlant, "D2", 2, RequirementUsage.ForSuppliersOnly, 1);
_requirementType.AddRequirementDefinition(_reqDefForSupplier);
_reqDefForOther = _reqDefWithTwoFields = new RequirementDefinition(TestPlant, "D3", 2, RequirementUsage.ForOtherThanSuppliers, 1);
_requirementType.AddRequirementDefinition(_reqDefForOther);
_numberFieldId = AddNumberField(context, _reqDefForOther, "N", "mm", true).Id;
_cbFieldId = AddCheckBoxField(context, _reqDefForOther, "CB").Id;
context.SaveChangesAsync().Wait();
}
}
private (Project, Action) CreateAction(PreservationContext context, string projectName, bool closeProject)
{
var plantId = _plantProvider.Plant;
var mode = new Mode(plantId, "M1", false);
context.Modes.Add(mode);
var responsible = new Responsible(plantId, "Resp1", "Resp1-Desc");
context.Responsibles.Add(responsible);
context.SaveChangesAsync().Wait();
var journey = new Journey(plantId, "J1");
var step = new Step(plantId, "S1", mode, responsible);
journey.AddStep(step);
context.Journeys.Add(journey);
context.SaveChangesAsync().Wait();
var requirementType = new RequirementType(plantId, "RT", "RT title", RequirementTypeIcon.Other, 1);
context.RequirementTypes.Add(requirementType);
var requirementDefinition = new RequirementDefinition(plantId, "RD", 2, RequirementUsage.ForAll, 1);
requirementType.AddRequirementDefinition(requirementDefinition);
context.SaveChangesAsync().Wait();
var project = new Project(plantId, projectName, $"{projectName} Desc")
{
IsClosed = closeProject
};
context.Projects.Add(project);
var tag = new Tag(
plantId,
TagType.Standard,
"Tag A",
"Tag desc",
step,
new List <TagRequirement> {
new TagRequirement(plantId, 2, requirementDefinition)
});
project.AddTag(tag);
context.SaveChangesAsync().Wait();
var action = new Action(plantId, "A", "D", null);
tag.AddAction(action);
var attachment = new ActionAttachment(plantId, Guid.Empty, "fil.txt");
action.AddAttachment(attachment);
context.SaveChangesAsync().Wait();
return(project, action);
}
private static RequirementDefinition SeedReqDef(PreservationContext dbContext, RequirementType reqType, string title)
{
var reqDef =
new RequirementDefinition(reqType.Plant, title, 4, RequirementUsage.ForAll, 10);
reqType.AddRequirementDefinition(reqDef);
dbContext.SaveChangesAsync().Wait();
return(reqDef);
}
public static void AddRequirementTypes(this IRequirementTypeRepository requirementTypeRepository, int entryCount, string plant)
{
for (var i = 0; i < entryCount; i++)
{
var requirementType = new RequirementType(plant, "Code", "Title", RequirementTypeIcon.Other, i);
for (var j = 0; j < 5; j++)
{
var requirementDefinition = new RequirementDefinition(plant, $"RequirementDefinition-{j}", 2, RequirementUsage.ForAll, j);
requirementType.AddRequirementDefinition(requirementDefinition);
}
requirementTypeRepository.Add(requirementType);
}
}
protected RequirementType AddRequirementTypeWith1DefWithoutField(PreservationContext context, string typeCode, string defTitle, RequirementTypeIcon icon, int sortKey = 0)
{
var requirementType = new RequirementType(TestPlant, typeCode, $"Title{typeCode}", icon, sortKey);
context.RequirementTypes.Add(requirementType);
context.SaveChangesAsync().Wait();
var requirementDefinition = new RequirementDefinition(TestPlant, defTitle, 2, RequirementUsage.ForAll, 1);
requirementType.AddRequirementDefinition(requirementDefinition);
context.SaveChangesAsync().Wait();
return(requirementType);
}
public void Setup()
{
// Arrange
_requirementTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
_requirementType = new RequirementType(TestPlant, "Code", "Title", RequirementTypeIcon.Other, 10);
_requirementDefinitionMock = new Mock <RequirementDefinition>();
_requirementDefinitionMock.SetupGet(s => s.Plant).Returns(TestPlant);
_requirementDefinitionMock.SetupGet(s => s.Id).Returns(_requirementDefinitionId);
_requirementDefinitionMock.Object.IsVoided = true;
_requirementType.AddRequirementDefinition(_requirementDefinitionMock.Object);
_requirementTypeRepositoryMock
.Setup(x => x.GetByIdAsync(_requirementTypeId))
.Returns(Task.FromResult(_requirementType));
_command = new DeleteRequirementDefinitionCommand(_requirementTypeId, _requirementDefinitionId, _rowVersion);
_dut = new DeleteRequirementDefinitionCommandHandler(_requirementTypeRepositoryMock.Object, UnitOfWorkMock.Object);
}
private void CloneRequirementDefinitions(RequirementType sourceRT, RequirementType targetRT)
{
foreach (var sourceRD in sourceRT.RequirementDefinitions)
{
var targetRD = targetRT.RequirementDefinitions.SingleOrDefault(t => t.Title == sourceRD.Title);
if (targetRD == null)
{
targetRD = new RequirementDefinition(
targetRT.Plant,
sourceRD.Title,
sourceRD.DefaultIntervalWeeks,
sourceRD.Usage,
sourceRD.SortKey);
targetRT.AddRequirementDefinition(targetRD);
}
CloneFields(sourceRD, targetRD);
}
}
public void Setup()
{
// Arrange
var reqTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
var requirementTypeId = 1;
var requirementDefinitionId = 2;
var requirementType = new RequirementType(TestPlant, "TestCode", "ReqTypeTitle", _reqIconOther, 99);
requirementType.SetProtectedIdForTesting(requirementTypeId);
_requirementDefinition = new RequirementDefinition(TestPlant, "ReqDefinitionTitle", 4, RequirementUsage.ForAll, 88);
_requirementDefinition.SetProtectedIdForTesting(requirementDefinitionId);
requirementType.AddRequirementDefinition(_requirementDefinition);
reqTypeRepositoryMock.Setup(m => m.GetByIdAsync(requirementTypeId))
.Returns(Task.FromResult(requirementType));
_command = new VoidRequirementDefinitionCommand(requirementTypeId, requirementDefinitionId, _rowVersion);
_dut = new VoidRequirementDefinitionCommandHandler(
reqTypeRepositoryMock.Object,
UnitOfWorkMock.Object);
}
protected override void SetupNewDatabase(DbContextOptions <PreservationContext> dbContextOptions)
{
using (var context = new PreservationContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var journey = AddJourneyWithStep(context, "J1", "S", AddMode(context, "M1", false), AddResponsible(context, "R1"));
var requirementType1 = new RequirementType(TestPlant, _requirementType1Code, _requirementType1Title, _requirementType1Icon, 0);
context.RequirementTypes.Add(requirementType1);
var requirementType2 = new RequirementType(TestPlant, _requirementType2Code, _requirementType2Title, _requirementType2Icon, 0);
context.RequirementTypes.Add(requirementType2);
context.SaveChangesAsync().Wait();
var requirementDefinitionWithoutField = new RequirementDefinition(TestPlant, _requirementDefinitionWithoutFieldTitle, 2, RequirementUsage.ForAll, 1);
requirementType1.AddRequirementDefinition(requirementDefinitionWithoutField);
var requirementDefinitionWithOneInfo = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneInfoTitle, 2, RequirementUsage.ForAll, 1);
var infoField = new Field(TestPlant, "Label for Info", FieldType.Info, 0);
requirementDefinitionWithOneInfo.AddField(infoField);
requirementType1.AddRequirementDefinition(requirementDefinitionWithOneInfo);
var requirementDefinitionWithOneAttachment = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneAttachmentTitle, 2, RequirementUsage.ForAll, 1);
var attachmentField = new Field(TestPlant, "Label for Attachment", FieldType.Attachment, 0);
requirementDefinitionWithOneAttachment.AddField(attachmentField);
requirementType1.AddRequirementDefinition(requirementDefinitionWithOneAttachment);
var requirementDefinitionWithTwoCheckBoxes = new RequirementDefinition(TestPlant, _requirementDefinitionWithTwoCheckBoxesTitle, 2, RequirementUsage.ForAll, 1);
var cbField1 = new Field(TestPlant, "Label for checkBox - second", FieldType.CheckBox, 10);
var cbField2 = new Field(TestPlant, "Label for checkBox - first", FieldType.CheckBox, 2);
requirementDefinitionWithTwoCheckBoxes.AddField(cbField1);
requirementDefinitionWithTwoCheckBoxes.AddField(cbField2);
requirementType2.AddRequirementDefinition(requirementDefinitionWithTwoCheckBoxes);
var requirementDefinitionWithThreeNumberShowPrev = new RequirementDefinition(TestPlant, _requirementDefinitionWithThreeNumberShowPrevTitle, 2, RequirementUsage.ForAll, 1);
var numberFieldPrev1 = new Field(TestPlant, "Label for number - third", FieldType.Number, 15, _unit, true);
var numberFieldPrev2 = new Field(TestPlant, "Label for number - first", FieldType.Number, 2, _unit, true);
var numberFieldPrev3 = new Field(TestPlant, "Label for number - second", FieldType.Number, 10, _unit, true);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev1);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev2);
requirementDefinitionWithThreeNumberShowPrev.AddField(numberFieldPrev3);
requirementType2.AddRequirementDefinition(requirementDefinitionWithThreeNumberShowPrev);
var requirementDefinitionWithOneNumberNoPrev = new RequirementDefinition(TestPlant, _requirementDefinitionWithOneNumberNoPrevTitle, 2, RequirementUsage.ForAll, 1);
var numberFieldNoPrev = new Field(TestPlant, "Label for number", FieldType.Number, 10, _unit, false);
requirementDefinitionWithOneNumberNoPrev.AddField(numberFieldNoPrev);
requirementType2.AddRequirementDefinition(requirementDefinitionWithOneNumberNoPrev);
var requirementDefinitionForVoidedTest = new RequirementDefinition(TestPlant, _requirementDefinitionForVoidedTest, 2, RequirementUsage.ForAll, 1);
var vField1 = new Field(TestPlant, "Label for field", FieldType.CheckBox, 10);
requirementDefinitionForVoidedTest.AddField(vField1);
requirementType2.AddRequirementDefinition(requirementDefinitionForVoidedTest);
context.SaveChangesAsync().Wait();
var requirementWithoutField = new TagRequirement(TestPlant, _interval, requirementDefinitionWithoutField);
var requirementWithOneInfo = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneInfo);
var requirementWithOneAttachment = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneAttachment);
var requirementWithTwoCheckBoxes = new TagRequirement(TestPlant, _interval, requirementDefinitionWithTwoCheckBoxes);
var requirementWithOneNumberNoPrev = new TagRequirement(TestPlant, _interval, requirementDefinitionWithOneNumberNoPrev);
var requirementWithThreeNumberShowPrev = new TagRequirement(TestPlant, _interval, requirementDefinitionWithThreeNumberShowPrev);
var requirementThatIsVoided = new TagRequirement(TestPlant, _interval, requirementDefinitionForVoidedTest);
requirementThatIsVoided.IsVoided = true;
var tag = new Tag(TestPlant,
TagType.Standard,
"TagNo",
"Description",
journey.Steps.ElementAt(0),
new List <TagRequirement>
{
requirementWithoutField,
requirementWithOneInfo,
requirementWithOneAttachment,
requirementWithTwoCheckBoxes,
requirementWithOneNumberNoPrev,
requirementWithThreeNumberShowPrev,
requirementThatIsVoided
});
context.Tags.Add(tag);
context.SaveChangesAsync().Wait();
_tagId = tag.Id;
_requirementDefinitionWithOneAttachmentId = requirementDefinitionWithOneAttachment.Id;
_requirementDefinitionWithTwoCheckBoxesId = requirementDefinitionWithTwoCheckBoxes.Id;
_requirementDefinitionWithThreeNumberShowPrevId = requirementDefinitionWithThreeNumberShowPrev.Id;
_requirementWithoutFieldId = requirementWithoutField.Id;
_requirementWithOneInfoId = requirementWithOneInfo.Id;
_requirementWithOneAttachmentId = requirementWithOneAttachment.Id;
_requirementWithTwoCheckBoxesId = requirementWithTwoCheckBoxes.Id;
_requirementWithThreeNumberShowPrevId = requirementWithThreeNumberShowPrev.Id;
_requirementWithOneNumberNoPrevId = requirementWithOneNumberNoPrev.Id;
_attachmentFieldId = attachmentField.Id;
_firstCbFieldId = cbField2.Id;
_secondCbFieldId = cbField1.Id;
_firstNumberFieldId = numberFieldPrev2.Id;
_secondNumberFieldId = numberFieldPrev3.Id;
_thirdNumberFieldId = numberFieldPrev1.Id;
}
}
public void Setup()
{
_dut = new RequirementType(TestPlant, "CodeA", "TitleA", RequirementTypeIcon.Other, 10);
_rd = new RequirementDefinition(TestPlant, "RD1", 4, RequirementUsage.ForAll, 0);
_dut.AddRequirementDefinition(_rd);
}
public void AddRequirementDefinition_ShouldThrowExceptionTest_WhenRequirementDefinitionNotGiven() => Assert.ThrowsException <ArgumentNullException>(() => _dut.AddRequirementDefinition(null));
public void Setup()
{
// Arrange
var requirementTypeId = 1;
var requirementDefinitionId = 2;
_fieldId = 3;
var requirementTypeRepositoryMock = new Mock <IRequirementTypeRepository>();
_requirementType = new RequirementType(TestPlant, "Req type code", "Req type title", RequirementTypeIcon.Other, 10);
_requirementType.SetProtectedIdForTesting(requirementTypeId);
_requirementDefinition = new RequirementDefinition(TestPlant, _oldTitle, _oldDefaultWeeks, _oldUsage, _oldSortKey);
_requirementDefinition.SetProtectedIdForTesting(requirementDefinitionId);
_field = new Field(TestPlant, _oldLabel, _oldFieldType, _oldSortKey, _oldUnit, _oldShowPrevious);
_field.SetProtectedIdForTesting(_fieldId);
_requirementDefinition.AddField(_field);
_requirementType.AddRequirementDefinition(_requirementDefinition);
requirementTypeRepositoryMock.Setup(j => j.GetByIdAsync(requirementTypeId))
.Returns(Task.FromResult(_requirementType));
_updateCommandWithUpdateField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>
{
new UpdateFieldsForCommand(_fieldId, _newLabel1, FieldType.Number, _newSortKey1, true, _rowVersion, _newUnit1, _newShowPrevious1)
},
new List <FieldsForCommand>()
);
_updateCommandWithDeleteField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>(),
new List <FieldsForCommand>()
);
_updateCommandWithUpdateAndAddField = new UpdateRequirementDefinitionCommand(
requirementTypeId,
requirementDefinitionId,
_newSortKey1,
_newUsage,
_newTitle,
_newDefaultWeeks,
_rowVersion,
new List <UpdateFieldsForCommand>
{
new UpdateFieldsForCommand(_fieldId, _newLabel1, FieldType.Number, _newSortKey1, true, _rowVersion, _newUnit1, _newShowPrevious1)
},
new List <FieldsForCommand>
{
new FieldsForCommand(_newLabel2, _newFieldType2, _newSortKey2, _newUnit2, _newShowPrevious2)
}
);
_dut = new UpdateRequirementDefinitionCommandHandler(
requirementTypeRepositoryMock.Object,
UnitOfWorkMock.Object,
PlantProviderMock.Object);
}
private (int, int) CreateTag(
PreservationContext context,
string projectName,
TagType tagType,
int intervalWeeks)
{
var plantId = _plantProvider.Plant;
_mode1 = new Mode(plantId, "M1", false);
_mode2 = new Mode(plantId, "M2", false);
context.Modes.Add(_mode1);
context.Modes.Add(_mode2);
_responsible1 = new Responsible(plantId, "Resp1", "Resp1-Desc");
_responsible2 = new Responsible(plantId, "Resp2", "Resp2-Desc");
context.Responsibles.Add(_responsible1);
context.Responsibles.Add(_responsible2);
context.SaveChangesAsync().Wait();
var journey = new Journey(plantId, "J1");
var step = new Step(plantId, "S1", _mode1, _responsible1);
journey.AddStep(step);
journey.AddStep(new Step(plantId, "S2", _mode2, _responsible2));
context.Journeys.Add(journey);
context.SaveChangesAsync().Wait();
var requirementType = new RequirementType(plantId, "RT", "RT title", RequirementTypeIcon.Other, 1);
context.RequirementTypes.Add(requirementType);
var requirementDefinition = new RequirementDefinition(plantId, "RD", intervalWeeks, RequirementUsage.ForAll, 1);
requirementType.AddRequirementDefinition(requirementDefinition);
context.SaveChangesAsync().Wait();
var project = new Project(plantId, projectName, $"{projectName} Desc");
context.Projects.Add(project);
var tag = new Tag(
plantId,
tagType,
"Tag A",
"Tag desc",
step,
new List <TagRequirement> {
new TagRequirement(plantId, _intervalWeeks1, requirementDefinition)
})
{
Calloff = "C",
CommPkgNo = "Cp",
McPkgNo = "Mp",
PurchaseOrderNo = "PO",
TagFunctionCode = "TF"
};
tag.SetArea("A", "A desc");
tag.SetDiscipline("D", "D desc");
project.AddTag(tag);
context.SaveChangesAsync().Wait();
return(project.Id, tag.Id);
}
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();
});
}