public void Should_Succeed()
{
// arrange
var command = UpdateGuildCommandFake.Valid().Generate();
var guildRepository = GuildRepositoryMockBuilder.Create()
.ExistsWithId(true, command.Id)
.CanChangeName(true, command.Id, command.Name)
.Build();
var memberRepository = MemberRepositoryMockBuilder.Create()
.ExistsWithId(true, command.LeaderId)
.IsGuildMember(true, command.LeaderId, command.Id)
.Build();
var sut = new UpdateGuildValidator(guildRepository, memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.Should().NotBeNull().And.BeOfType <ValidationResult>();
result.IsValid.Should().BeTrue();
}
public async Task Handle_Should_Succeed_With_ValidCommand()
{
// arrange
var promotedMember = MemberFake.GuildMember().Generate();
var guild = promotedMember.GetGuild();
var expectedDemotedMember = promotedMember.GetGuild().GetLeader();
var command = PatchMemberCommandFake.PromoteMemberValid(promotedMember.Id).Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.GetForGuildOperationsSuccess(command.Id, promotedMember)
.Update(promotedMember, promotedMember)
.Update(expectedDemotedMember, expectedDemotedMember)
.Build();
var sut = new PromoteMemberHandler(memberRepository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <MemberTestProxy>();
result.Data.As <Member>().Id.Should().Be(promotedMember.Id);
result.Data.As <Member>().IsGuildLeader.Should().BeTrue()
.And.Be(!expectedDemotedMember.IsGuildLeader);
result.Data.As <Member>().GetGuild().Should().NotBeNull();
result.Data.As <Member>().GetGuild().Id.Should().Be(guild.Id);
}
public async Task Handle_Should_Succeed_With_ValidCommand_GuildMember()
{
// arrange
var leavingMember = (MemberTestProxy)MemberFake.GuildMember().Generate();
var expectedUnchangedLeader = leavingMember.GetGuild().GetLeader();
var expectedFinishedMembership = leavingMember.GetActiveMembership();
var command = PatchMemberCommandFake.LeaveGuildValid(leavingMember.Id).Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.GetForGuildOperationsSuccess(command.Id, leavingMember)
.Update(leavingMember, leavingMember)
.Update(expectedUnchangedLeader, expectedUnchangedLeader)
.Build();
var membershipRepository = MembershipRepositoryMockBuilder.Create()
.Update(expectedFinishedMembership, expectedFinishedMembership).Build();
var sut = new LeaveGuildHandler(memberRepository, membershipRepository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <MemberTestProxy>();
result.Data.As <Member>().Id.Should().Be(leavingMember.Id);
result.Data.As <Member>().IsGuildLeader.Should().BeFalse()
.And.Be(!expectedUnchangedLeader.IsGuildLeader);
result.Data.As <Member>().GetGuild().Should().BeOfType <NullGuild>();
expectedFinishedMembership.Should().NotBeOfType <NullMembership>();
expectedFinishedMembership.Id.Should().Be(leavingMember.GetLastFinishedMembership().Id);
expectedFinishedMembership.ModifiedDate.Should().NotBeNull()
.And.Be(leavingMember.GetLastFinishedMembership().ModifiedDate);
}
public async Task Handle_Should_Succeed_With_ValidCommand()
{
// arrange
var expectedMember = MemberFake.WithoutGuild().Generate();
var command = PatchMemberCommandFake.ChangeMemberNameValid(
id: expectedMember.Id,
name: expectedMember.Name).Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.GetByIdSuccess(command.Id, expectedMember)
.Update(expectedMember, expectedMember)
.Build();
var sut = new ChangeMemberNameHandler(memberRepository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <MemberTestProxy>();
result.Data.As <Member>().Name.Should().Be(expectedMember.Name);
result.Data.As <Member>().Id.Should().Be(expectedMember.Id);
}
public async Task Handle_Should_Succeed_With_ValidCommand()
{
// arrange
var expectedPage = new Random().Next(1, 5);
var expectedPages = new Random().Next(expectedPage, expectedPage + 1);
var expectedPageSize = new Random().Next(5, 10);
var command = ListMemberCommandFake.Valid(expectedPageSize, expectedPage).Generate();
var totalItems = command.PageSize * expectedPages;
var repository = MemberRepositoryMockBuilder.Create().Paginate(command, totalItems).Build();
var sut = new ListMemberHandler(repository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <PagedResponse <Member> >();
result.Data.As <PagedResponse <Member> >().Items.Should().NotBeEmpty()
.And.AllBeAssignableTo <Member>()
.And.HaveCount(expectedPageSize)
.And.HaveCount(command.PageSize)
.And.Match(x => x.All(y => y.Name.Contains(command.Name, StringComparison.OrdinalIgnoreCase) ||
y.GuildId == command.GuildId));
result.Data.As <PagedResponse <Member> >().PageSize.Should().Be(expectedPageSize)
.And.Be(command.PageSize);
result.Data.As <PagedResponse <Member> >().Page.Should().Be(expectedPage)
.And.Be(command.Page);
result.Data.As <PagedResponse <Member> >().Pages.Should().Be(expectedPages);
}
public void Should_Fail_By_Empty_Id()
{
// arrange
var command = PatchMemberCommandFake.DemoteMemberInvalidByEmptyId().Generate();
var memberRepository = MemberRepositoryMockBuilder.Create().Build();
var sut = new DemoteMemberValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public void Should_Fail_By_Member_NotGuildLeader()
{
// arrange
var member = MemberFake.GuildMember().Generate();
var command = PatchMemberCommandFake.DemoteMemberValid(member.Id).Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.GetByIdSuccess(member.Id, member).Build();
var sut = new DemoteMemberValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public void Should_Fail_By_Member_ExistsWithName_True()
{
// arrange
var command = CreateMemberCommandFake.Valid().Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.ExistsWithName(true, command.Name).Build();
var sut = new CreateMemberValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public void Should_Fail_By_Empty_MasterId()
{
// arrange
var command = CreateGuildCommandFake.InvalidByEmptyMasterId().Generate();
var guildRepository = GuildRepositoryMockBuilder.Create().Build();
var memberRepository = MemberRepositoryMockBuilder.Create().Build();
var sut = new CreateGuildValidator(guildRepository, memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public void Should_Succeed()
{
// arrange
var member = MemberFake.GuildLeader().Generate();
var command = PatchMemberCommandFake.DemoteMemberValid(member.Id).Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.GetByIdSuccess(member.Id, member).Build();
var sut = new DemoteMemberValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.Should().NotBeNull().And.BeOfType <ValidationResult>();
result.IsValid.Should().BeTrue();
}
public void Should_Succeed()
{
// arrange
var command = CreateMemberCommandFake.Valid().Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.ExistsWithName(false, command.Name).Build();
var sut = new CreateMemberValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.Should().NotBeNull().And.BeOfType <ValidationResult>();
result.IsValid.Should().BeTrue();
}
public void Should_Fail_By_Member_NotFound()
{
// arrange
var command = PatchMemberCommandFake.ChangeMemberNameValid().Generate();
var memberRepository = MemberRepositoryMockBuilder.Create()
.ExistsWithId(false, command.Id)
.CanChangeName(true, command.Id, command.Name).Build();
var sut = new ChangeMemberNameValidator(memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public async Task Handle_Should_Succeed_With_ValidCommandAsync()
{
// arrange
var command = CreateMemberCommandFake.Valid().Generate();
var expectedMember = MemberFake.WithoutGuild(command.Name).Generate();
var repository = MemberRepositoryMockBuilder.Create().Insert(command.Name, expectedMember).Build();
var factory = ModelFactoryMockBuilder.Create().CreateMember(command.Name, expectedMember).Build();
var sut = new CreateMemberHandler(repository, factory);
// act
var response = await sut.Handle(command, default);
// assert
response.Should().NotBeNull().And.BeOfType <SuccessCreatedResult>();
response.Success.Should().BeTrue();
response.Errors.Should().BeEmpty();
response.As <SuccessCreatedResult>().StatusCode.Should().Be(StatusCodes.Status201Created);
response.Data.Should().NotBeNull().And.BeOfType <MemberTestProxy>();
response.Data.As <Member>().Should().Be(expectedMember);
}
public void Should_Fail_By_Master_ExistsWithId_False()
{
// arrange
var command = CreateGuildCommandFake.Valid().Generate();
var guildRepository = GuildRepositoryMockBuilder
.Create().ExistsWithName(false, command.Name).Build();
var memberRepository = MemberRepositoryMockBuilder
.Create().ExistsWithId(false, command.LeaderId).Build();
var sut = new CreateGuildValidator(guildRepository, memberRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public async Task Handle_Should_Succeed_With_ValidCommand()
{
// arrange
var expectedMember = MemberFake.GuildLeader().Generate();
var command = GetMemberCommandFake.Valid(expectedMember.Id).Generate();
var repository = MemberRepositoryMockBuilder.Create()
.GetByIdSuccess(input: command.Id, output: expectedMember).Build();
var sut = new GetMemberHandler(repository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <MemberTestProxy>();
result.Data.As <Member>().Id.Should().Be(expectedMember.Id);
result.Data.As <Member>().GetGuild().Id.Should().Be(expectedMember.GuildId.Value);
}
public void Should_Fail_By_Guild_ExistsWithId_False()
{
// arrange
var command = InviteMemberCommandFake.Valid().Generate();
var guildRepository = GuildRepositoryMockBuilder.Create()
.ExistsWithId(false, command.GuildId).Build();
var memberRepository = MemberRepositoryMockBuilder.Create()
.ExistsWithId(true, command.MemberId)
.IsGuildMember(false, command.MemberId, command.GuildId)
.Build();
var sut = new InviteMemberValidator(memberRepository, guildRepository)
{
CascadeMode = FluentValidation.CascadeMode.Stop
};
// act
var result = sut.Validate(command);
// assert
result.AssertErrorsCount(1);
}
public async Task Handle_Should_Succeed_With_ValidCommand()
{
// arrange
var expectedGuild = GuildFake.Complete().Generate();
var expectedMembersCount = expectedGuild.Members.Count;
var expectedLeader = expectedGuild.GetVice();
var expectedVice = expectedGuild.GetLeader();
var command = UpdateGuildCommandFake.Valid(
id: expectedGuild.Id,
leaderId: expectedLeader.Id,
name: expectedGuild.Name).Generate();
var guildRepository = GuildRepositoryMockBuilder.Create()
.GetByIdSuccess(command.Id, expectedGuild)
.Update(expectedGuild, expectedGuild).Build();
var memberRepository = MemberRepositoryMockBuilder.Create()
.Update(expectedLeader, expectedLeader)
.Update(expectedVice, expectedVice)
.Build();
var sut = new UpdateGuildHandler(guildRepository, memberRepository);
// act
var result = await sut.Handle(command, default);
// assert
result.Should().NotBeNull().And.BeOfType <SuccessResult>();
result.Success.Should().BeTrue();
result.Errors.Should().BeEmpty();
result.As <SuccessResult>().StatusCode.Should().Be(StatusCodes.Status200OK);
result.Data.Should().NotBeNull().And.BeOfType <GuildTestProxy>();
result.Data.As <Guild>().Name.Should().Be(expectedGuild.Name);
result.Data.As <Guild>().Id.Should().Be(expectedGuild.Id);
result.Data.As <Guild>().GetLeader().Id.Should().Be(expectedLeader.Id);
result.Data.As <Guild>().Members.Should().NotBeEmpty()
.And.HaveCount(expectedMembersCount)
.And.Contain(x => x.Id == expectedLeader.Id)
.And.Contain(x => x.Id == expectedVice.Id);
}
