public void Setup()
{
_projectRepositoryMock = new Mock <IProjectRepository>();
var stepMock = new Mock <Step>();
stepMock.SetupGet(s => s.Plant).Returns(TestPlant);
var rdMock = new Mock <RequirementDefinition>();
rdMock.SetupGet(rd => rd.Id).Returns(_rdId1);
rdMock.SetupGet(rd => rd.Plant).Returns(TestPlant);
_requirement = new TagRequirement(TestPlant, _intervalWeeks, rdMock.Object);
_tag = new Tag(TestPlant, TagType.Standard, "", "", stepMock.Object, new List <TagRequirement> {
_requirement
})
{
StorageArea = _oldStorageArea,
Remark = _oldRemark
};
var tagId = 2;
_projectRepositoryMock
.Setup(r => r.GetTagByTagIdAsync(tagId))
.Returns(Task.FromResult(_tag));
_command = new UpdateTagCommand(tagId, _newRemark, _newStorageArea, _rowVersion);
_dut = new UpdateTagCommandHandler(
_projectRepositoryMock.Object,
UnitOfWorkMock.Object);
}
public async Task CanUpdateTag()
{
var authorizedClient = SystemTestExtension.GetTokenAuthorizeHttpClient(_factory);
var updateTagCommand = new UpdateTagCommand
{
Id = 1,
Name = "taggg",
ToQuestion = true
};
var serializedUpdateCommand = JsonConvert.SerializeObject(updateTagCommand);
// The endpoint or route of the controller action.
var httpResponse = await authorizedClient.PutAsync(requestUri : "/Tag",
content : new StringContent(content: serializedUpdateCommand,
encoding: Encoding.UTF8,
mediaType: StringConstants.ApplicationJson));
//Must be successful
httpResponse.EnsureSuccessStatusCode();
Assert.True(httpResponse.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.OK, httpResponse.StatusCode);
}
public void Constructor_ShouldSetProperties()
{
var dut = new UpdateTagCommand(2, "Remark", "StorageArea", "AAAAAAAAABA=");
Assert.AreEqual(2, dut.TagId);
Assert.AreEqual("Remark", dut.Remark);
Assert.AreEqual("StorageArea", dut.StorageArea);
Assert.AreEqual("AAAAAAAAABA=", dut.RowVersion);
}
public async override Task <string> Handle(UpdateTagCommand request, CancellationToken cancellationToken)
{
Entity = repo.Find(request.ID);
Entity.Name = request.Name;
Result = repo.Update(Entity);
return(Result);
}
public async Task <ActionResult> Update(int id, UpdateTagCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public void Setup_OkState()
{
_projectValidatorMock = new Mock <IProjectValidator>();
_tagValidatorMock = new Mock <ITagValidator>();
_tagValidatorMock.Setup(r => r.ExistsAsync(_tagId, default)).Returns(Task.FromResult(true));
_rowVersionValidatorMock = new Mock <IRowVersionValidator>();
_rowVersionValidatorMock.Setup(r => r.IsValid(_rowVersion)).Returns(true);
_command = new UpdateTagCommand(_tagId, _remark, _storageArea, _rowVersion);
_dut = new UpdateTagCommandValidator(_projectValidatorMock.Object, _tagValidatorMock.Object, _rowVersionValidatorMock.Object);
}
public void Validate_ShouldFail_WhenInvalidRowVersion()
{
const string invalidRowVersion = "String";
var command = new UpdateTagCommand(_tagId, _remark, _storageArea, invalidRowVersion);
_rowVersionValidatorMock.Setup(r => r.IsValid(invalidRowVersion)).Returns(false);
var result = _dut.Validate(command);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.IsTrue(result.Errors[0].ErrorMessage.StartsWith("Not a valid row version!"));
}
public async Task ShouldGetModelForValidInformation()
{
var updateTag = new UpdateTagCommand
{
Id = _tagId,
TenantId = _tenantId,
UpdatedBy = _adminUserId,
ToQuestion = true,
Name = "tag1"
};
var tagModel = await _updateTagCommandHandler.Handle(updateTag, CancellationToken.None);
Assert.Null(tagModel.Errors);
}
public async Task <ActionResult <string> > UpdateTag(
[FromHeader(Name = CurrentPlantMiddleware.PlantHeader)]
[Required]
string plant,
[FromRoute] int id,
[FromBody] UpdateTagDto dto)
{
var command = new UpdateTagCommand(id,
dto.Remark,
dto.StorageArea,
dto.RowVersion);
var result = await _mediator.Send(command);
return(this.FromResult(result));
}
public async Task ShouldUpdateTag()
{
var createTagCommand = new CreateTagCommand("t1", createProjectDto.Id);
var createTagDto = await SendAsync(createTagCommand);
var updateTagCommand = new UpdateTagCommand(createTagDto.Id, createProjectDto.Id, "t edit", "description 1");
await SendAsync(updateTagCommand);
var scenarioEntity = await ExecuteDbContextAsync(db => db.Tags
.SingleOrDefaultAsync(p => p.Id.Equals(createTagDto.Id))
);
scenarioEntity.ShouldNotBeNull();
scenarioEntity.Name.ShouldBe("t edit");
scenarioEntity.Description.ShouldBe("description 1");
var deleteTagCommand = new DeleteTagCommand(createTagDto.Id, createProjectDto.Id);
await SendAsync(deleteTagCommand);
}
public Tag UpdateTag(UpdateTagCommand updateTagCommand)
{
try
{
Tag tag = _tagRepository.GetTagById(updateTagCommand.TagId);
if (tag == null)
{
throw new ObjectNotFoundException($"No tag found with the id of {updateTagCommand.TagId}");
}
tag.Text = updateTagCommand.TagText;
_tagRepository.SaveTag(tag);
UnitOfWork.SaveChanges();
return(tag);
}
catch (Exception ex)
{
Logger.LogError(new EventId(101), ex, "Error thrown while calling TagService.UpdateTag()");
throw ex;
}
}
public async Task <ActionResult <ResponseModel <UpdateTagModel> > > Put([FromBody] UpdateTagCommand command)
{
try
{
command.UpdatedBy = Claims[ClaimTypes.Sid].ToInt();
command.TenantId = Guid.Parse(Claims[ClaimTypes.UserData]);
var updateTagModel = await Mediator.Send(command);
return(Ok(updateTagModel));
}
catch (NotFoundException)
{
return(NotFound());
}
catch (ObjectAlreadyExistsException ex)
{
return(Conflict(new ResponseModel <UpdateTagModel>(new Error(HttpStatusCode.Conflict, ex))));
}
catch
{
return(StatusCode(HttpStatusCode.InternalServerError.ToInt()));
}
}
public async Task <ActionResult> Put(UpdateTagCommand command)
{
await Sender.Send(command);
return(NoContent());
}
public async Task <ActionResult> Update([FromBody] UpdateTagCommand updateTagCommand)
{
await this._mediator.Send(updateTagCommand);
return(this.NoContent());
}
public async Task <IActionResult> Update(UpdateTagCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
