public void Validate_ShouldBeValid_WithoutRequirements()
{
var command = new UpdateRequirementsCommand("", "", new List <RequirementForCommand>());
var result = _dut.Validate(command);
Assert.IsTrue(result.IsValid);
}
public void Constructor_ShouldSetProperties_WithoutRequirements()
{
var dut = new UpdateRequirementsCommand("TFC", "RC", null);
Assert.IsNotNull(dut.Requirements);
Assert.AreEqual(0, dut.Requirements.Count());
}
public IHttpActionResult CreateUpdateRequirement([FromUri] int projectId, [FromBody] UpdateRequirementsCommand command)
{
if (command == null || projectId <= 0)
{
return(BadRequest(DefaultMessages.InvalidBody));
}
List <UpdateRequirementsCommand> commands = new List <UpdateRequirementsCommand>()
{
command
};
ValidationError error = new UpdateRequirementsCommandValidator().Validate(commands);
if (error.IsInvalid)
{
return(BadRequest(error.Error));
}
ProjectsRepository projectsRepository = new ProjectsRepository(Connection, HttpContext.Current.User);
if (projectsRepository.Find(projectId) == null)
{
return(BadRequest("Projeto não encontrado."));
}
List <Requirement> requirements = new RequirementsService().MapCommand(commands);
RequirementsRepository repository = new RequirementsRepository(Connection);
repository.Update(projectId, requirements);
return(Ok());
}
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);
}
public void Constructor_ShouldSetProperties_WithRequirements()
{
var req = new RequirementForCommand(1, 2);
var dut = new UpdateRequirementsCommand("TFC", "RC", new List <RequirementForCommand> {
req
});
Assert.AreEqual("TFC", dut.TagFunctionCode);
Assert.AreEqual("RC", dut.RegisterCode);
Assert.AreEqual(1, dut.Requirements.Count());
Assert.AreEqual(req, dut.Requirements.Single());
}
public void Validate_ShouldFail_WhenRequirementsNotUnique()
{
var command = new UpdateRequirementsCommand("", "",
new List <RequirementForCommand>
{
new RequirementForCommand(_rd1Id, 1),
new RequirementForCommand(_rd1Id, 1)
});
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 Setup_OkState()
{
_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));
_command = new UpdateRequirementsCommand("", "",
new List <RequirementForCommand>
{
new RequirementForCommand(_rd1Id, 1),
new RequirementForCommand(_rd2Id, 1)
});
_dut = new UpdateRequirementsCommandValidator(_rdValidatorMock.Object);
}
private static Requirement CreateCommandToRequirement(UpdateRequirementsCommand command)
{
Requirement requirement = new Requirement()
{
Id = command.Id,
ParentId = command.ParentId,
Completed = command.Completed,
Name = command.Name,
Description = command.Description,
Children = new List <Requirement>()
};
if (command.Children != null)
{
foreach (UpdateRequirementsCommand child in command.Children)
{
requirement.Children.Add(CreateCommandToRequirement(child));
}
}
return(requirement);
}
