public async Task UpdateShouldSucceed()
        {
            // Arrange
            var id   = Guid.NewGuid();
            var name = "name";
            var nameOnApplication = "nameOnApplication";
            var description       = "description";
            var icon           = new RemarkIcon(Guid.NewGuid());
            var defaultRemark  = new DefaultRemark("defaultRemark1");
            var defaultRemarks = new List <DefaultRemark>()
            {
                defaultRemark
            };
            var tags = new List <Tag>();

            var remark = RepositoryHelper.ForRemark.CreateRemark(id, name, nameOnApplication, description, icon, defaultRemarks, tags);

            var tag = new Tag("tag1");

            remark.AddTag(tag);

            // Act
            await _repository.UpdateAsync(remark);

            // Assert
            var data = RepositoryHelper.ForRemark.GetRemarks();

            data.Should().HaveCount(1);
            var result = data.First();

            result.Should().NotBeNull();
            result.Tags.Should().HaveCount(1);
            result.Tags.First().Should().Be(tag);
        }
Exemplo n.º 2
0
        public async Task <Result> Handle(UpdateRemarkCommand request, CancellationToken cancellationToken)
        {
            Result result;

            try
            {
                var icon = await _remarkReadRepository.GetAsync(request.Id);

                if (icon.Version != request.Version)
                {
                    throw new CommandVersionException();
                }

                var updatedRemark = new Remark(request.Id, request.Name, request.NameOnApplication, request.Description, new RemarkIcon(request.Icon));
                request.Tags.ToList().ForEach(x => updatedRemark.AddTag(new Tag(x)));
                request.DefaultRemarks.ToList().ForEach(x => updatedRemark.AddDefaultRemark(new DefaultRemark(x)));

                updatedRemark.Version = _versionProvider.Generate();
                await _remarkWriteRepository.UpdateAsync(updatedRemark);

                result = Result.Ok(updatedRemark.Version);
            }
            catch (EntityNotFoundDbException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.NotFound.Name,
                        Message = string.Format(HandlerFailures.NotFound, "Remark"),
                        Target  = "id"
                    }
                }
                                     );
            }
            catch (CommandVersionException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.NotMet.Name,
                        Message = HandlerFailures.NotMet,
                        Target  = "version"
                    }
                }
                                     );
            }
            catch (UniqueKeyException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.Conflict.Name,
                        Message = HandlerFailures.Conflict,
                        Target  = "name"
                    }
                }
                                     );
            }
            catch
            {
                result = Result.Fail(CustomFailures.UpdateRemarkFailure);
            }

            return(result);
        }