public void Create_ValidParams_AccountReturned()
{
//Arrange
var idGuid = Guid.Parse("051f8160-ce43-4ac0-b8c2-09707c2bcda3");
var id = AccountId.FromGuid(idGuid);
var ownerGuid = Guid.Parse("4bc0c0e9-7181-45e4-934d-e91c0e7bbd75");
var ownerId = UserId.FromGuid(ownerGuid);
var period = Period.FromMonth(2020, 9);
var currency = CurrencyCode.FromString("EUR");
//Act
var account = AccountRoot.Create(id, ownerId, period, currency);
//Assert
Assert.IsNotNull(account);
Assert.AreEqual(idGuid, account.Id);
Assert.AreEqual(ownerGuid, account.OwnerId.Value);
Assert.AreEqual(DateTime.Parse("2020-09-01"), account.Period.StartDate);
Assert.AreEqual(DateTime.Parse("2020-09-30"), account.Period.EndDate);
Assert.AreEqual("EUR", account.Currency.Value);
Assert.AreEqual(1, account.GetChanges().Count);
Assert.AreEqual(typeof(V1.AccountCreated), account.GetChanges()[0].GetType());
var @event = account.GetChanges()[0] as V1.AccountCreated;
Assert.AreEqual(idGuid, @event.AccountId);
Assert.AreEqual(ownerGuid, @event.OwnerId);
Assert.AreEqual(DateTime.Parse("2020-09-01"), @event.StartDate);
Assert.AreEqual(DateTime.Parse("2020-09-30"), @event.EndDate);
Assert.AreEqual("EUR", @event.CurrencyCode);
Assert.AreEqual(AccountState.AccountStateEnum.Open, account.State.Value);
}
public void ChangeBooking_BookingDoesNotExist_InvalidOperationException()
{
//Arrange
var bookingIdGuid = Guid.Parse("b9c18f4d-8f11-408d-be7c-c7f022abefb2");
var bookingId = BookingId.FromGuid(bookingIdGuid);
var payment = Payment.FromDecimal(100.00m, "EUR");
var bookingDate = BookingDate.FromString("2020-09-26");
var description = Description.FromString("My payment");
var accountIdGuid = Guid.Parse("9ccf4aa8-cd1e-4044-a183-464c8a8730ec");
var account = AccountRoot.Create(
AccountId.FromGuid(accountIdGuid),
UserId.FromGuid(Guid.Parse("13f172e2-7189-4506-b232-894bafcd4449")),
Period.FromMonth(2020, 9),
CurrencyCode.FromString("EUR"));
account.BookPayment(bookingId, payment, bookingDate, description);
var nonExistingBookingId = BookingId.FromGuid(Guid.Parse("58bead84-e4d6-481b-9c7a-b52a36a98c3f"));
var changedPayment = Payment.FromDecimal(200.00m, "EUR");
var changedBookingDate = BookingDate.FromString("2020-09-01");
var changedDescription = Description.FromString("My payment changed");
//Act & Assert
Assert.Throws <InvalidOperationException>(() => account.ChangeBooking(nonExistingBookingId, changedPayment, changedBookingDate, changedDescription));
}
protected override void SetStateByEvent(IEvent @event)
{
switch (@event)
{
case AdvertisementCreated e:
Id = e.Id;
OwnerId = UserId.FromGuid(e.OwnerId);
State = AdvertisementState.Inactive;
break;
case AdvertisementPriceUpdated e:
Price = new Price(Rial.FromLong(e.Price));
break;
case AdvertisementSentForReview e:
State = AdvertisementState.ReviewPending;
break;
case AdvertisementDescriptionUpdated e:
Description = AdvertisementDescription.FromString(e.Description);
break;
case AdvertisementTitleUpdated e:
Title = AdvertisementTitle.FromString(e.Title);
break;
default:
throw new InvalidOperationException("امکان اجرای عملیات درخواستی وجود ندارد");
}
}
public async Task <DomainValidationResult <UserProfile> > CreateProfileAsync(
User user,
string firstName,
string lastName,
Gender gender
)
{
var result = new DomainValidationResult <UserProfile>();
if (user.Profile != null)
{
result.AddFailedPreconditionError("The user's profile has already been created.");
}
if (result.IsValid)
{
var profile = new UserProfile(firstName, lastName, gender);
user.Create(profile);
//await this.UpdateSecurityStampAsync(user);
await this.UpdateUserAsync(user);
await _publisher.PublishUserProfileChangedIntegrationEventAsync(UserId.FromGuid(user.Id), profile);
return(profile);
}
return(result);
}
protected async override Task <ClearanceRoot> Apply(OpenClearanceCommand command, CancellationToken cancellationToken)
{
var clearanceDto = await clearanceDtoRepository.GetClearanceIdForUserOnPeriod(command.UserId, command.StartDate, command.EndDate);
if (clearanceDto == null)
{
var clearance = await ClearanceRoot.Open(
Domain.ClearanceId.FromGuid(command.ClearanceId),
Kernel.UserId.FromGuid(command.UserId),
Domain.AccountId.FromGuid(command.AccountId),
Kernel.Period.FromStartAndEndDate(command.StartDate, command.EndDate),
userSettingsService,
clearanceDtoRepository
);
return(clearance);
}
else
{
AggregateRoot = await GetAggregateFromRepo();
AggregateRoot.AddAccount(UserId.FromGuid(command.UserId), AccountId.FromGuid(command.AccountId));
return(AggregateRoot);
}
}
public async Task <DomainValidationResult <Doxatag> > ChangeDoxatagAsync(User user, string doxatagName)
{
var result = new DomainValidationResult <Doxatag>();
if (result.IsValid)
{
var codes = await _doxatagRepository.FetchDoxatagCodesByNameAsync(doxatagName);
var code = Doxatag.GenerateUniqueCode(codes);
var doxatag = new Doxatag(
UserId.FromGuid(user.Id),
doxatagName,
code,
new UtcNowDateTimeProvider());
_doxatagRepository.Create(doxatag);
await _doxatagRepository.UnitOfWork.CommitAsync();
return(doxatag);
}
return(result);
}
public async Task EditCustomer(Guid customerId, Customer editedCustomer)
{
Customer customer = await _customerRepository.Get(UserId.FromGuid(customerId));
customer.Edit(editedCustomer);
await _customerRepository.Update(customer);
}
public void ChangeBooking_BookingWithDifferentCurrency_PaymentNotSameCurrencyAsAccountException()
{
//Arrange
var bookingIdGuid = Guid.Parse("b9c18f4d-8f11-408d-be7c-c7f022abefb2");
var bookingId = BookingId.FromGuid(bookingIdGuid);
var payment = Payment.FromDecimal(100.00m, "EUR");
var bookingDate = BookingDate.FromString("2020-09-26");
var description = Description.FromString("My payment");
var accountIdGuid = Guid.Parse("9ccf4aa8-cd1e-4044-a183-464c8a8730ec");
var account = AccountRoot.Create(
AccountId.FromGuid(accountIdGuid),
UserId.FromGuid(Guid.Parse("13f172e2-7189-4506-b232-894bafcd4449")),
Period.FromMonth(2020, 9),
CurrencyCode.FromString("EUR"));
account.BookPayment(bookingId, payment, bookingDate, description);
var changedPayment = Payment.FromDecimal(200.00m, "USD");
var changedBookingDate = BookingDate.FromString("2020-09-01");
var changedDescription = Description.FromString("My payment changed");
//Act & Assert
Assert.Throws <PaymentNotSameCurrencyAsAccountException>(() => account.ChangeBooking(bookingId, changedPayment, changedBookingDate, changedDescription));
}
public Task Handle(V1.Create command)
=> Handle(
command.ClassifiedAdId,
state => ClassifiedAd.Create(
ClassifiedAdId.FromGuid(command.ClassifiedAdId),
UserId.FromGuid(command.SellerId)
)
);
#pragma warning disable CC0068 // Unused Method
#pragma warning disable IDE0051 // Remove unused private members
#pragma warning disable CC0057 // Unused parameters
#pragma warning disable IDE0060 // Remove unused parameter
private void Handle(V1.AccountCreated @event)
{
Id = @event.AccountId;
OwnerId = UserId.FromGuid(@event.OwnerId);
Period = Period.FromStartAndEndDate(@event.StartDate, @event.EndDate);
State = AccountState.CreateOpen();
Currency = CurrencyCode.FromString(@event.CurrencyCode);
}
public void UserId_DefaultGuid_ArgumentNullException()
{
//Arrange
var guid = Guid.Empty;
//Act & Assert
Assert.Throws <ArgumentNullException>(() => UserId.FromGuid(guid));
}
public Task Handle(V1.CreateOrder command)
=> Handle(
command.OrderId,
state => Order.Create(
OrderId.FromGuid(command.OrderId),
ClassifiedAdId.FromGuid(command.ClassifiedAdId),
UserId.FromGuid(command.CustomerId)
)
);
public ClassifiedAdsCommandService(
IAggregateStore store,
ICurrencyLookup currencyLookup,
UploadFile uploader) : base(store)
{
CreateWhen <V1.Create>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(cmd, id) => ClassifiedAd.Create(
ClassifiedAdId.FromGuid(id),
UserId.FromGuid(cmd.OwnerId)
)
);
UpdateWhen <V1.ChangeTitle>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd)
=> ad.SetTitle(ClassifiedAdTitle.FromString(cmd.Title))
);
UpdateWhen <V1.UpdateText>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd)
=> ad.UpdateText(ClassifiedAdText.FromString(cmd.Text))
);
UpdateWhen <V1.UpdatePrice>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd) => ad.UpdatePrice(
Price.FromDecimal(
cmd.Price, cmd.Currency ?? "EUR", currencyLookup
)
)
);
UpdateWhen <V1.RequestToPublish>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd) => ad.RequestToPublish()
);
UpdateWhen <V1.Publish>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd) => ad.Publish(UserId.FromGuid(cmd.ApprovedBy))
);
UpdateWhen <V1.Delete>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
(ad, cmd) => ad.Delete()
);
UpdateWhen <V1.UploadImage>(
cmd => ClassifiedAdId.FromGuid(cmd.Id),
async(ad, cmd) => ad.AddPicture(
await uploader(cmd.Image), new PictureSize(2000, 2000)
)
);
}
public async Task ShouldBeHttpStatusCodeOK()
{
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var factory = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var userManager = scope.GetRequiredService <IUserService>();
await userManager.CreateAsync(user);
var addressService = scope.GetRequiredService <IAddressService>();
var result = await addressService.AddAddressAsync(
UserId.FromGuid(user.Id),
Country.Canada,
"1234 Test Street",
null,
"Toronto",
"ON",
"A1A 1A1");
result.IsValid.Should().BeTrue();
var addressBook = await addressService.FetchAddressBookAsync(user);
// Act
using var response = await this.ExecuteAsync(
addressBook.First().Id,
new UpdateAddressRequest
{
CountryIsoCode = EnumCountryIsoCode.CA,
Line1 = "1234 Test Street",
Line2 = null,
City = "Toronto",
State = "ON",
PostalCode = "A1A 1A1"
});
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var message = await response.Content.ReadAsStringAsync();
message.Should().NotBeNullOrWhiteSpace();
});
}
protected async override Task <AccountRoot> Apply(CreateCommand command, CancellationToken cancellationToken)
{
var account = AccountRoot.Create(
AccountId.FromGuid(command.AccountDto.Id),
UserId.FromGuid(command.AccountDto.OwnerId),
Period.FromMonth(command.AccountDto.Year, command.AccountDto.Month),
CurrencyCode.FromString(command.AccountDto.Currency));
return(await Task.FromResult(account));
}
public void GetUsers_ShouldContainAdminId()
{
// Arrange
var storage = TestData.FileStorage;
// Act
var users = storage.GetUsers();
// Assert
users.Should().Contain(userId => userId == UserId.FromGuid(Guid.Parse("e4655fe0-affd-4323-b022-bdb2ebde6091")));
}
public void UserId_ValidGuid_Created()
{
//Arrange
var guid = Guid.Parse("dca2b44e-6ea7-4812-8c2f-ca772512ca01");
//Act
var userId = UserId.FromGuid(guid);
//Assert
Assert.AreEqual(guid, userId.Value);
}
public void Handle(CreateCommand command)
{
if (_repository.Exists(command.Id))
{
throw new InvalidOperationException($"قبلا آگهی با شناسه {command.Id} ثبت شده است.");
}
var advertisement = new Advertisement(command.Id, UserId.FromGuid(command.OwnerId));
_repository.Add(advertisement);
_unitOfWork.Commit();
}
public void Entities_With_Same_Id_Are_Equals()
{
//arrange
var userId = UserId.FromGuid(Guid.NewGuid());
//act
var user = new User(userId, "Manuel", "Hernández", "*****@*****.**", "Software Developer");
var userUpdated = new User(userId, "Angel", "Garcia", "*****@*****.**", "Staff Software Developer");
//assert
bool isTrue = user.Equals(userUpdated) && user == userUpdated &&
user.GetHashCode() == userUpdated.GetHashCode();
Assert.True(isTrue);
}
public async Task <bool> Handle(UploadUserProfilePhotoCommand request, CancellationToken cancellationToken)
{
var user = await _userRepository.GetAsync(UserId.FromGuid(request.UserId));
if (user == null)
{
throw new UserNotFoundException("User not found");
}
user.UploadPhoto(request.FileName, request.Photo);
await _userRepository.UnitOfWork.CommitChanges();
return(true);
}
public async Task ShouldBeHttpStatusCodeOK()
{
var users = TestData.FileStorage.GetUsers();
var user = users.First();
var factory = TestHost.WithClaimsFromBearerAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var userManager = scope.GetRequiredService <IUserService>();
await userManager.CreateAsync(user);
var addressService = scope.GetRequiredService <IAddressService>();
var result = await addressService.AddAddressAsync(
UserId.FromGuid(user.Id),
Country.Canada,
"1234 Test Street",
null,
"Toronto",
"Ontario",
"A1A1A1");
result.IsValid.Should().BeTrue();
var addressBook = await addressService.FetchAddressBookAsync(user);
// Act
using var response = await this.ExecuteAsync();
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
var mapper = scope.GetRequiredService <IMapper>();
var addressResponse = await response.Content.ReadAsJsonAsync <ICollection <AddressDto> >();
addressResponse.Should().BeEquivalentTo(mapper.Map <ICollection <AddressDto> >(addressBook));
});
}
public void Entities_With_Different_Id_Are_Not_Equals()
{
//arrange
var userId = UserId.FromGuid(Guid.NewGuid());
var updateUserId = UserId.FromGuid(Guid.NewGuid());
//act
var user = new User(userId, "Manuel", "Hernández",
"*****@*****.**", "Software Developer");
var userUpdated = new User(updateUserId, "Manuel", "Hernández",
"*****@*****.**", "Software Developer");
//assert
bool isTrue = !user.Equals(userUpdated) && user != userUpdated &&
user.GetHashCode() != userUpdated.GetHashCode();
Assert.True(isTrue);
}
protected override void When(object @event)
{
Picture picture;
switch (@event)
{
case V1.ClassifiedAdCreated e:
Id = e.Id;
OwnerId = UserId.FromGuid(e.OwnerId);
State = ClassifiedAdState.Inactive;
_pictures = new List <Picture>();
break;
case V1.ClassifiedAdTitleChanged e:
Title = new ClassifiedAdTitle(e.Title);
break;
case V1.ClassifiedAdTextUpdated e:
Text = new ClassifiedAdText(e.AdText);
break;
case V1.ClassifiedAdPriceUpdated e:
Price = new Price(e.Price, e.CurrencyCode);
break;
case V1.ClassifiedAdSentForReview _:
State = ClassifiedAdState.PendingReview;
break;
case V1.ClassifiedAdPublished e:
ApprovedBy = UserId.FromGuid(e.ApprovedBy);
State = ClassifiedAdState.Active;
break;
// picture
case V1.PictureAddedToAClassifiedAd e:
picture = new Picture(Apply);
ApplyToEntity(picture, e);
_pictures.Add(picture);
break;
case V1.ClassifiedAdPictureResized e:
picture = FindPicture(new PictureId(e.PictureId));
ApplyToEntity(picture, @event);
break;
}
}
public void ChangeBooking_ValidParams_BookingAddedToAccount()
{
//Arrange
var bookingIdGuid = Guid.Parse("b9c18f4d-8f11-408d-be7c-c7f022abefb2");
var bookingId = BookingId.FromGuid(bookingIdGuid);
var payment = Payment.FromDecimal(100.00m, "EUR");
var bookingDate = BookingDate.FromString("2020-09-26");
var description = Description.FromString("My payment");
var accountIdGuid = Guid.Parse("9ccf4aa8-cd1e-4044-a183-464c8a8730ec");
var account = AccountRoot.Create(
AccountId.FromGuid(accountIdGuid),
UserId.FromGuid(Guid.Parse("13f172e2-7189-4506-b232-894bafcd4449")),
Period.FromMonth(2020, 9),
CurrencyCode.FromString("EUR"));
account.BookPayment(bookingId, payment, bookingDate, description);
var changedPayment = Payment.FromDecimal(200.00m, "EUR");
var changedBookingDate = BookingDate.FromString("2020-09-20");
var changedDescription = Description.FromString("My payment changed");
//Act
account.ChangeBooking(bookingId, changedPayment, changedBookingDate, changedDescription);
//Assert
Assert.IsNotNull(account.Bookings);
Assert.IsNotNull(account.Bookings[0]);
var booking = account.Bookings[0];
Assert.AreEqual(bookingIdGuid, booking.Id.Value);
Assert.AreEqual(200.00m, booking.Payment.Amount);
Assert.AreEqual("EUR", booking.Payment.CurrencyCode);
Assert.AreEqual(DateTime.Parse("2020-09-20"), booking.Date.Value);
Assert.AreEqual("My payment changed", booking.Description.Value);
Assert.AreEqual(3, account.GetChanges().Count);
Assert.AreEqual(typeof(V1.BookingChanged), account.GetChanges()[2].GetType());
var @event = account.GetChanges()[2] as V1.BookingChanged;
Assert.AreEqual(accountIdGuid, @event.AccountId);
Assert.AreEqual(bookingIdGuid, @event.BookingId);
Assert.AreEqual(200.00m, @event.Amount);
Assert.AreEqual("EUR", @event.CurrencyCode);
Assert.AreEqual(DateTime.Parse("2020-09-20"), @event.Date);
Assert.AreEqual("My payment changed", @event.Description);
}
private async Task SeedAdministratorAsync()
{
if (!await Users.AnyAsync(user => user.Id == AppAdministrator.Id))
{
var user = new User(UserId.FromGuid(AppAdministrator.Id), "*****@*****.**");
Users.Add(user);
await this.CommitAsync();
Logger.LogInformation("The administrator being populated.");
}
else
{
Logger.LogInformation("The administrator already populated.");
}
}
public static Participant ToEntity(this ParticipantModel model)
{
var participant = new Participant(
ParticipantId.FromGuid(model.Id),
UserId.FromGuid(model.UserId),
PlayerId.Parse(model.PlayerId),
new DateTimeProvider(model.RegisteredAt));
if (model.SynchronizedAt.HasValue && model.Matches != null)
{
participant.Snapshot(model.Matches.Select(match => match.ToEntity()), new DateTimeProvider(model.SynchronizedAt.Value));
}
participant.ClearDomainEvents();
return(participant);
}
public void Close_AccountAlreadyClosed_InvalidOperationException()
{
//Arrange
var idGuid = Guid.Parse("051f8160-ce43-4ac0-b8c2-09707c2bcda3");
var id = AccountId.FromGuid(idGuid);
var ownerGuid = Guid.Parse("4bc0c0e9-7181-45e4-934d-e91c0e7bbd75");
var ownerId = UserId.FromGuid(ownerGuid);
var period = Period.FromMonth(2020, 9);
var currency = CurrencyCode.FromString("EUR");
var account = AccountRoot.Create(id, ownerId, period, currency);
account.Close();
//Act & Assert
Assert.Throws <InvalidOperationException>(() => account.Close());
}
public void BookPayment_PaymentDateOutsidePeriod_InvalidEntityStateException()
{
//Arrange
var bookingIdGuid = Guid.Parse("b9c18f4d-8f11-408d-be7c-c7f022abefb2");
var bookingId = BookingId.FromGuid(bookingIdGuid);
var payment = Payment.FromDecimal(100.00m, "EUR");
var bookingDate = BookingDate.FromString("2020-01-01");
var description = Description.FromString("My payment");
var accountIdGuid = Guid.Parse("9ccf4aa8-cd1e-4044-a183-464c8a8730ec");
var account = AccountRoot.Create(
AccountId.FromGuid(accountIdGuid),
UserId.FromGuid(Guid.Parse("13f172e2-7189-4506-b232-894bafcd4449")),
Period.FromMonth(2020, 9),
CurrencyCode.FromString("EUR"));
//Act & Assert
Assert.Throws <InvalidEntityState>(() => account.BookPayment(bookingId, payment, bookingDate, description));
}
private async Task SeedAdministratorAccountAsync()
{
var userId = UserId.FromGuid(AppAdministrator.Id);
if (!await Accounts.AnyAsync(account => account.Id == userId))
{
var account = new Account(userId);
Accounts.Add(account.ToModel());
await this.CommitAsync();
Logger.LogInformation("The administrator account being populated.");
}
else
{
Logger.LogInformation("The administrator account already populated.");
}
}
public async Task RemoveAddressAsync_ShouldBeOkObjectResult()
{
// Arrange
var user = new User
{
Id = Guid.NewGuid()
};
var address = new Address(
UserId.FromGuid(user.Id),
Country.Canada,
"Line1",
null,
"City",
"State",
"PostalCode");
TestMock.UserService.Setup(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable();
TestMock.AddressService.Setup(addressService => addressService.FindUserAddressAsync(It.IsAny <User>(), It.IsAny <AddressId>()))
.ReturnsAsync(address)
.Verifiable();
TestMock.AddressService.Setup(addressService => addressService.RemoveAddressAsync(It.IsAny <Address>()))
.ReturnsAsync(DomainValidationResult <Address> .Succeeded(address))
.Verifiable();
var controller = new AddressBookController(TestMock.UserService.Object, TestMock.AddressService.Object, TestMapper);
// Act
var result = await controller.RemoveAddressAsync(address.Id);
// Assert
result.Should().BeOfType <OkObjectResult>();
TestMock.UserService.Verify(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>()), Times.Once);
TestMock.AddressService.Verify(addressService => addressService.FindUserAddressAsync(It.IsAny <User>(), It.IsAny <AddressId>()), Times.Once);
TestMock.AddressService.Verify(addressService => addressService.RemoveAddressAsync(It.IsAny <Address>()), Times.Once);
}