public async Task CreateTags_ShouldCreateCorrectCommand()
{
CreateTagsCommand _createdCommand = null;
_mediatorMock
.Setup(x => x.Send(It.IsAny <CreateTagsCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SuccessResult <List <int> >(new List <int> {
5
}) as Result <List <int> >))
.Callback <IRequest <Result <List <int> > >, CancellationToken>((request, cancellationToken) =>
{
_createdCommand = request as CreateTagsCommand;
});
_createTagsDto.ProjectName = "ProjectName";
_createTagsDto.StepId = 2;
_createTagsDto.TagNos = new List <string> {
"TagNo1", "TagNo2"
};
await _dut.CreateTags("", _createTagsDto);
Assert.AreEqual(_createTagsDto.ProjectName, _createdCommand.ProjectName);
Assert.AreEqual(_createTagsDto.StepId, _createdCommand.StepId);
Assert.AreEqual(2, _createdCommand.TagNos.Count());
Assert.AreEqual(_createTagsDto.TagNos.First(), _createdCommand.TagNos.First());
Assert.AreEqual(_createTagsDto.TagNos.Last(), _createdCommand.TagNos.Last());
}
public void Constructor_ShouldSetProperties_WithRequirements()
{
var dut = new CreateTagsCommand(
new List <string> {
"TagNoA"
},
"ProjectNameA",
2,
new List <RequirementForCommand> {
new RequirementForCommand(11, 12)
},
"RemarkA",
"SA_A");
Assert.AreEqual("ProjectNameA", dut.ProjectName);
Assert.AreEqual("RemarkA", dut.Remark);
Assert.AreEqual("SA_A", dut.StorageArea);
Assert.AreEqual(2, dut.StepId);
Assert.AreEqual(1, dut.Requirements.Count());
var requirement = dut.Requirements.First();
Assert.AreEqual(11, requirement.RequirementDefinitionId);
Assert.AreEqual(12, requirement.IntervalWeeks);
Assert.AreEqual(1, dut.TagNos.Count());
Assert.AreEqual("TagNoA", dut.TagNos.First());
}
public void Validate_ShouldFail_WhenRequirementsNotUnique()
{
_rdValidatorMock.Setup(r => r.UsageCoversBothForSupplierAndOtherAsync(new List <int> {
_rd1Id, _rd1Id
}, default)).Returns(Task.FromResult(true));
var command = new CreateTagsCommand(
new List <string> {
_tagNo1
},
_projectName,
_stepId,
new List <RequirementForCommand>
{
new RequirementForCommand(_rd1Id, 1),
new RequirementForCommand(_rd1Id, 1)
},
null,
null);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("Requirement definitions must be unique!"));
}
public void Constructor_ShouldSetProperties_WithNullLists()
{
var dut = new CreateTagsCommand(null, "", 0, null, null, null);
Assert.IsNotNull(dut.Requirements);
Assert.AreEqual(0, dut.Requirements.Count());
Assert.IsNotNull(dut.TagNos);
Assert.AreEqual(0, dut.TagNos.Count());
Assert.IsNull(dut.Remark);
Assert.IsNull(dut.StorageArea);
}
public static QueryAsyncJobResultResponse CreateTagsForSnapshot(string resourceId)
{
var resourceIds = new List <string> {
resourceId
};
var tags = new Dictionary <string, string> {
{ ConfigurationHelper.TagKey, ConfigurationHelper.TagValue }
};
var cmd = new CreateTagsCommand(resourceIds, tags, CreateTagsCommand.SnapshotResourceType);
cmd.ExecuteCommand();
Thread.Sleep(ConfigurationHelper.CommandExecutionDelayInSeconds);
return(cmd.QueryAsyncJobResultResponse);
}
public void Validate_ShouldFail_WhenNoTagNosGiven()
{
var command = new CreateTagsCommand(
new List <string>(),
_projectName,
_stepId,
_requirements,
null,
null);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("At least 1 TagNo must be given!"));
}
public void Validate_ShouldFailForSupplierStep_WhenNoRequirementsGiven()
{
var command = new CreateTagsCommand(
new List <string> {
_tagNo1, _tagNo2
},
_projectName,
_stepId,
new List <RequirementForCommand>(),
null,
null);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("Requirements must include requirements to be used both for supplier and other than suppliers!"));
}
public void Validate_ShouldFail_WhenNoTagNosNotUnique()
{
var command = new CreateTagsCommand(
new List <string> {
"X", "x"
},
_projectName,
_stepId,
_requirements,
null,
null);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("Tags must be unique!"));
}
public void Validate_ShouldFailForNonSupplierStep_WhenNoRequirementsGiven()
{
_stepValidatorMock.Setup(r => r.IsForSupplierAsync(_stepId, default)).Returns(Task.FromResult(false));
var command = new CreateTagsCommand(
new List <string> {
_tagNo1, _tagNo2
},
_projectName,
_stepId,
new List <RequirementForCommand>(),
null,
null);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("Requirements must include requirements to be used for other than suppliers!"));
}
public async Task <ActionResult <int> > MigrateTags(
[FromHeader(Name = CurrentPlantMiddleware.PlantHeader)]
[Required]
[StringLength(PlantEntityBase.PlantLengthMax, MinimumLength = PlantEntityBase.PlantLengthMin)]
string plant,
[FromBody] CreateTagsDto dto)
{
var requirements = dto.Requirements?
.Select(r =>
new RequirementForCommand(r.RequirementDefinitionId, r.IntervalWeeks));
var command = new CreateTagsCommand(
dto.TagNos,
dto.ProjectName,
dto.StepId,
requirements,
dto.Remark,
dto.StorageArea);
var result = await _mediator.Send(command);
return(this.FromResult(result));
}
public void Setup_OkState()
{
_tagValidatorMock = new Mock <ITagValidator>();
_stepValidatorMock = new Mock <IStepValidator>();
_stepValidatorMock.Setup(r => r.ExistsAsync(_stepId, default)).Returns(Task.FromResult(true));
_stepValidatorMock.Setup(r => r.IsForSupplierAsync(_stepId, default)).Returns(Task.FromResult(true));
_projectValidatorMock = new Mock <IProjectValidator>();
_rdValidatorMock = new Mock <IRequirementDefinitionValidator>();
_rdValidatorMock.Setup(r => r.ExistsAsync(_rd1Id, default)).Returns(Task.FromResult(true));
_rdValidatorMock.Setup(r => r.ExistsAsync(_rd2Id, default)).Returns(Task.FromResult(true));
_rdValidatorMock.Setup(r => r.UsageCoversBothForSupplierAndOtherAsync(new List <int> {
_rd1Id, _rd2Id
}, default)).Returns(Task.FromResult(true));
_requirements = new List <RequirementForCommand>
{
new RequirementForCommand(_rd1Id, 1),
new RequirementForCommand(_rd2Id, 1)
};
_command = new CreateTagsCommand(
new List <string> {
_tagNo1, _tagNo2
},
_projectName,
_stepId,
_requirements,
null,
null);
_dut = new CreateTagsCommandValidator(
_tagValidatorMock.Object,
_stepValidatorMock.Object,
_projectValidatorMock.Object,
_rdValidatorMock.Object);
}
public async Task <IActionResult> CreateTags([FromBody] CreateTagsCommand command)
{
var response = await _mediator.Send(command);
return(CreateResponse(response));
}
public void Setup()
{
_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 rdMock2 = new Mock <RequirementDefinition>();
rdMock2.SetupGet(x => x.Id).Returns(ReqDefId2);
rdMock2.SetupGet(x => x.Plant).Returns(TestPlant);
_rtRepositoryMock
.Setup(r => r.GetRequirementDefinitionsByIdsAsync(new List <int> {
ReqDefId1, ReqDefId2
}))
.Returns(Task.FromResult(new List <RequirementDefinition> {
rdMock1.Object, rdMock2.Object
}));
_mainTagDetails1 = new PCSTagDetails
{
AreaCode = "AreaCode1",
AreaDescription = "AreaDescription1",
CallOffNo = "CalloffNo1",
CommPkgNo = "CommPkgNo1",
Description = "Description1",
DisciplineCode = "DisciplineCode1",
DisciplineDescription = "DisciplineDescription1",
McPkgNo = "McPkgNo1",
PurchaseOrderNo = "PurchaseOrderNo1",
TagFunctionCode = "TagFunctionCode1",
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",
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 CreateTagsCommand(
new List <string> {
TestTagNo1, TestTagNo2
},
TestProjectName,
_step.Id,
new List <RequirementForCommand>
{
new RequirementForCommand(ReqDefId1, Interval1),
new RequirementForCommand(ReqDefId2, Interval2),
},
"Remark",
"SA");
_dut = new CreateTagsCommandHandler(
_projectRepositoryMock.Object,
_journeyRepositoryMock.Object,
_modeRepositoryMock.Object,
_rtRepositoryMock.Object,
UnitOfWorkMock.Object,
PlantProviderMock.Object,
_tagApiServiceMock.Object);
}
