public void ShouldRequireFields()
{
var command = new CreateAddressCommand();
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public Result Handle(CreateAddressCommand command)
{
// createAddressResult contains all error messages if address data is invalid
var createAddressResult = Address.Create(command.Street, command.Number, command.City);
// Return failed result if address is invalid. Return ASAP
if (createAddressResult.IsFailed)
{
return(createAddressResult.ToResult());
}
var customer = _repository.GetById(command.CustomerId);
var addAddressResult = customer.AddAddress(createAddressResult.Value);
// Return failed result if adding address is not possible because of business rules. Return ASAP
if (addAddressResult.IsFailed)
{
return(addAddressResult);
}
// Manipulations are commited and return success result if nothing failed
_repository.Commit();
return(Result.Ok());
}
public void CallCompleteOfDataBase_WhenAddressIsCreatedAddress()
{
//Arrange
var streetParam = "street";
var postalCodeParam = "1715";
var townId = 1;
var validParameters = new List <string>()
{
streetParam, postalCodeParam, townId.ToString()
};
var dbMock = new Mock <IDatabase>();
var factoryMock = new Mock <IModelsFactory>();
var addressMock = new Mock <Address>();
factoryMock.Setup(f => f.CreateAddress(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Town>())).Returns(addressMock.Object);
var townMock = new Mock <Town>();
var townRepositoryMock = new Mock <ITownRepository>();
townRepositoryMock.Setup(s => s.SingleOrDefault(It.IsAny <Expression <Func <Town, bool> > >())).Returns(townMock.Object);
dbMock.Setup(d => d.Towns).Returns(townRepositoryMock.Object);
var addressRepositoryMock = new Mock <IAddessRepository>();
dbMock.Setup(d => d.Addesses).Returns(addressRepositoryMock.Object);
var sut = new CreateAddressCommand(dbMock.Object, factoryMock.Object);
//Act
var result = sut.Execute(validParameters);
//Assert
dbMock.Verify(d => d.Complete(), Times.Once);
}
public async Task <CreateAddressCommand> CreateAddress(string token, CreateAddressCommand command)
{
var result = await _requestProvider.PostAsync(GlobalSetting.Instance.AddressEndPoint, command,
Settings.AccessToken);
return(result);
}
public async Task ShouldCreateCreateAddress()
{
var userId = await RunAsDefaultUserAsync();
var employeeId = await SendAsync(new CreateEmployeeCommand
{
FirstName = "TestFirstName",
LastName = "TestUpdateLastName",
Email = "*****@*****.**",
Pesel = "12345612"
});
var command = new CreateAddressCommand
{
EmployeeId = employeeId,
Street = "Łąćna",
City = "Poznań",
PostCode = "66666"
};
var addressId = await SendAsync(command);
var addr = await FindAsync <Address>(addressId);
addr.Should().NotBeNull();
addr.EmployeeId.Should().Be(command.EmployeeId);
addr.Street.Should().Be(command.Street);
addr.City.Should().Be(command.City);
addr.PostCode.Should().Be(command.PostCode);
addr.CreatedBy.Should().Be(userId);
addr.Created.Should().BeCloseTo(DateTime.Now, 10000);
addr.LastModifiedBy.Should().BeNull();
addr.LastModified.Should().BeNull();
}
public ActionResult <Company> CreateAddress([FromRoute] int id, [FromBody] CreateAddressCommand command)
{
command.CompanyId = id;
var company = _companyService.CreateAddress(command);
return(Ok(company));
}
public void ShouldNotCreateAddress_When_CommandIsInvalid()
{
var command = new CreateAddressCommand("", "", "", "", "", EAddressType.Billing, Guid.NewGuid());
var handler = new AddressCommandHandler(null);
var result = handler.Handle(command);
Assert.False(result.IsValid);
}
public void ShouldCreateAddress_When_CommandIsValid()
{
var command = new CreateAddressCommand("Street One", "London", "LND", "England", "77777", EAddressType.Billing, Guid.NewGuid());
var handler = new AddressCommandHandler(null);
var result = handler.Handle(command);
Assert.True(result.IsValid);
}
public void CompleteAddress(CreateAddressCommand createAddress, string personID)
{
var address = new Address(createAddress.City, createAddress.ZipCode, createAddress.StreetName, personID, createAddress.StreetNumber, createAddress.HomeNumber);
var imapper = AutoMapperConfig.GetMapper(); // mapuje obiekt domenowy na płaski obiekt
var addressDTO = imapper.Map <Address, AddressDTO>(address);
addressRepository.Create(addressDTO);
}
public async Task <IActionResult> Address(CreateAddressCommand command)
{
if (command == null)
{
throw new BadRequestException("BAD_REQUEST", @"Bad Request");
}
return(Ok(await Mediator.Send(command)));
}
public async Task <IActionResult> Create(int userId, CreateAddressCommand command)
{
if (userId != UserId)
{
return(Unauthorized());
}
var address = await _mediator.Send(command);
return(CreatedAtRoute(nameof(GetAddress), new { userId, id = address.Id }, address));
}
public IActionResult Post([FromBody] CreateAddressCommand command)
{
var result = _handler.Handle(command);
if (!result.IsValid)
{
return(BadRequest(result));
}
return(Ok(result));
}
public Address Create(CreateAddressCommand command)
{
var Address = new Address(command.CEP, command.State, command.City, command.Street, command.Number, command.Type, command.Description);
Address.Validate();
_repository.Create(Address);
if (Commit())
{
return(Address);
}
return(null);
}
public void ReturnNotValidParameters_WhenParametersAreDifferentOfThree(params string[] parameters)
{
//Arrange
var dbMock = new Mock <IDatabase>();
var factoryMock = new Mock <IModelsFactory>();
var sut = new CreateAddressCommand(dbMock.Object, factoryMock.Object);
var expectedString = "Not valid number";
//Act
var result = sut.Execute(parameters);
//Assert
StringAssert.Contains(expectedString, result);
}
public void ReturnParametersAreEmpty_WhenSomeOfTheParametersIsEmpty(params string[] parameters)
{
//Arrange
var dbMock = new Mock <IDatabase>();
var factoryMock = new Mock <IModelsFactory>();
var sut = new CreateAddressCommand(dbMock.Object, factoryMock.Object);
var expectedString = "parameters are empty";
//Act
var result = sut.Execute(parameters);
//Assert
StringAssert.Contains(expectedString, result);
}
public void ReturnNotValidTownId_WhenThirdParameterCannotBeParsedToInt(params string[] parameters)
{
//Arrange
var dbMock = new Mock <IDatabase>();
var factoryMock = new Mock <IModelsFactory>();
var sut = new CreateAddressCommand(dbMock.Object, factoryMock.Object);
var expectedString = "Not Valid Town Id";
//Act
var result = sut.Execute(parameters);
//Assert
StringAssert.Contains(expectedString, result);
}
public async Task CreateAddress_UserAlreadyHasAPrimaryAddress_ShouldSetCurrentPrimaryAddressToFalse()
{
var sut = new CreateAddressCommandHandler(_context);
var currentUser = _context.User.First();
var addressCountBeforeAct = _context.Address.ToList().Count;
var oldPrimaryAddress =
_context.Address.First(x => x.UserId == currentUser.Id && x.PrimaryAddress);
var command = new CreateAddressCommand {
City = "Glasgow", UserId = currentUser.Id, PrimaryAddress = true
};
await sut.Handle(command, CancellationToken.None);
oldPrimaryAddress.PrimaryAddress.ShouldBe(false);
_context.Address.First(x => x.UserId == currentUser.Id && x.PrimaryAddress).City.ShouldBe("Glasgow");
_context.Address.Count().ShouldBe(addressCountBeforeAct + 1);
}
public Company CreateAddress(CreateAddressCommand command)
{
var company = GetCompany(command.CompanyId);
company.Addresses.Add(new CompanyAddresses
{
CompanyAddressType = CompanyAddressType.Office,
Address = new Address
{
Street = command.Street,
Number = command.Number,
Postcode = command.Postcode
}
});
_contactsContext.SaveChanges();
return(company);
}
public ActionResult CompleteAddress(CreateAddressCommand createAddress)
{
var personDTO = personService.Load(User.Identity.GetUserId());
var addressDTO = personService.LoadAddress(personDTO.PersonID);
if (addressDTO != null)
{
ViewBag.Message = "Już dodałeś adres czy chcesz go zaktualizować ?";
}
if (addressDTO == null && ModelState.IsValid)
{
personService.CompleteAddress(createAddress, personDTO.PersonID);
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public async Task Delete_Address_Should_Return_Status_Code_204()
{
var registerCommand = new RegisterCommand()
{
FirstName = "FirstNameTestDelete",
LastName = "LastNameTestDelete",
CompanyName = "TestCompanyDelete",
Email = "*****@*****.**",
ConfirmEmail = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
UserDetailsDto user = await AuthHelper.SignUp(_httpClient, registerCommand);
var newAddress = new CreateAddressCommand()
{
UserId = user.Id,
Alias = "My home",
FirstName = user.FirstName,
Lastname = user.LastName,
Place = "Warszawa",
PostCode = "00-005",
Street = "test54",
BuildingNumber = "12A",
Phone = "000-000-000",
Email = user.Email
};
var createdAddress = await _httpClient.PostAsync <CreateAddressCommand, AddressDetailsDto>
($"/api/users/{user.Id}/addresses", newAddress);
var responseDeletedAddress = await _httpClient.DeleteAsync($"/api/users/{user.Id}/addresses/{createdAddress.Id}");
var deletedAddress = await _httpClient.GetAsync <AddressDetailsDto>($"api/users/{user.Id}/addresses/{createdAddress.Id}");
Assert.Equal(HttpStatusCode.NoContent, responseDeletedAddress.StatusCode);
Assert.Null(deletedAddress);
}
public void ReturnSuchIdDoesNotExist_WhenTownIsNotInTheRepository()
{
//Arrange
var validParameters = new List <string>()
{
"street", "postalcode", "1"
};
var dbMock = new Mock <IDatabase>();
var factoryMock = new Mock <IModelsFactory>();
var townRepositoryMock = new Mock <ITownRepository>();
townRepositoryMock.Setup(s => s.SingleOrDefault(It.IsAny <Expression <Func <Town, bool> > >())).Returns((Town)null);
dbMock.Setup(d => d.Towns).Returns(townRepositoryMock.Object);
var sut = new CreateAddressCommand(dbMock.Object, factoryMock.Object);
var expectedString = "such id doesn't exist";
//Act
var result = sut.Execute(validParameters);
//Assert
StringAssert.Contains(expectedString, result);
}
public ICommandResult Handle(CreateAddressCommand command)
{
throw new NotImplementedException();
}
public async Task Run()
{
var tokenSource = new CancellationTokenSource();
// Create 2 people at 1 address
var addAddressCommand1 = new CreateAddressCommand
{
Street = "15 My Street",
Suburb = "Springfield",
State = "My State",
Country = "Safe Country",
PostalCode = "12345"
};
await _processCommands.Execute(addAddressCommand1, tokenSource.Token).ConfigureAwait(false);
var addCustomerCommand1 = new CreateCustomerCommand
{
FirstName = "Bob",
LastName = "Jones",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand1.CreatedEntity.Id
//Commit = false
};
var addCustomerCommand2 = new CreateCustomerCommand
{
FirstName = "Herbert",
LastName = "Scrackle",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand1.CreatedEntity.Id
//Commit = false
};
await _processCommands.Execute(addCustomerCommand1, tokenSource.Token).ConfigureAwait(false);
await _processCommands.Execute(addCustomerCommand2, tokenSource.Token).ConfigureAwait(false);
// Now create 1 person at a second address
var addAddressCommand2 = new CreateAddressCommand
{
Street = "742 Evergreen Terrace",
Suburb = "Springfield",
State = "Unknown",
Country = "USA",
PostalCode = "Unknown"
};
await _processCommands.Execute(addAddressCommand2, tokenSource.Token).ConfigureAwait(false);
var addCustomerCommand3 = new CreateCustomerCommand
{
FirstName = "Homer",
LastName = "Simpson",
EmailAddress = "*****@*****.**",
AddressId = addAddressCommand2.CreatedEntity.Id
//Commit = false
};
await _processCommands.Execute(addCustomerCommand3, tokenSource.Token).ConfigureAwait(false);
Console.WriteLine("Records created: 2 addresses, 3 people");
// Now test getting data back
{
// Query using "Projector" pattern where the mapping is done on Sql Server rather than in this application.
// This approach is more efficient as only the required data ever comes back to the application
var customersByQuery = new CustomersBy
{
FirstName = "Bob"
};
var results = await _processQueries.Execute(customersByQuery, tokenSource.Token).ConfigureAwait(false);
var resultsList = results?.ToList();
Console.WriteLine($"Querying for Customer with First Name of '{customersByQuery.FirstName}' returns {resultsList?.Count ?? 0}");
if (resultsList != null && resultsList.Count > 0)
{
var json = JsonSerializer.Serialize(resultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Query using Include expressions. There may be scenarios where an include is required. EF Core poses restrictions
// when using AsExpandable() from LinqKit, so this QueryHandler shows how to pass Include expressions to Query<TEntity>(...)
var customersWithIncludeByQuery = new CustomersWithIncludeBy()
{
FirstName = "Bob"
};
var resultsUsingInclude = await _processQueries.Execute(customersWithIncludeByQuery, tokenSource.Token).ConfigureAwait(false);
var resultsList = resultsUsingInclude?.ToList();
Console.WriteLine($"Querying for Customer with First Name of '{customersWithIncludeByQuery.FirstName}' returns {resultsList?.Count ?? 0}");
if (resultsList != null && resultsList.Count > 0)
{
var json = JsonSerializer.Serialize(resultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Get a single address
var addressesByQuery = new AddressesBy
{
Id = addAddressCommand1.CreatedEntity.Id
};
var addressResults = await _processQueries.Execute(addressesByQuery, tokenSource.Token).ConfigureAwait(false);
var addressResultsList = addressResults?.ToList();
Console.WriteLine($"Querying for Address with id {addAddressCommand1.CreatedEntity.Id} returns {addressResultsList?.Count ?? 0}");
if (addressResultsList != null && addressResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(addressResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result (1 address):");
Console.WriteLine(json);
}
Console.WriteLine();
}
{
// Get all address
var addressesByQuery = new AddressesBy
{
};
var addressResults = await _processQueries.Execute(addressesByQuery, tokenSource.Token).ConfigureAwait(false);
var addressResultsList = addressResults?.ToList();
Console.WriteLine($"Querying for all Addresses returns {addressResultsList?.Count ?? 0}");
if (addressResultsList != null && addressResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(addressResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result (multiple addresses):");
Console.WriteLine(json);
}
Console.WriteLine();
}
// Create an Employer, and a CustomerEmployerMapping for one of the Customers above
var addEmployerCommand = new CreateEmployerCommand
{
Name = "Springfield Power Plant"
};
await _processCommands.Execute(addEmployerCommand, tokenSource.Token);
var addCustomerEmployerMappingComand = new CreateCustomerEmployerMappingCommand
{
CustomerId = addCustomerCommand3.CreatedEntity.Id,
EmployerId = addEmployerCommand.CreatedEntity.Id
};
await _processCommands.Execute(addCustomerEmployerMappingComand, tokenSource.Token);
{
// And now show the full details of all CustomerEmployerMappings, includinging drilling down
var getAllCEMs = new GetCustomerEmployerMappings();
var cemResults = await _processQueries.Execute(getAllCEMs, tokenSource.Token).ConfigureAwait(false);
var cemResultsList = cemResults?.ToList();
Console.WriteLine($"Querying for all CustomerEmployerMappings returns {cemResultsList?.Count ?? 0}");
if (cemResultsList != null && cemResultsList.Count > 0)
{
var json = JsonSerializer.Serialize(cemResultsList, new JsonSerializerOptions
{
WriteIndented = true
});
Console.WriteLine("Query result:");
Console.WriteLine(json);
}
Console.WriteLine();
}
}
public async Task <ActionResult> Create([FromForm] CreateAddressCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public CreateAddressCommandValidatorTests()
{
this.createValidator = new CreateAddressCommandValidator();
this.createCommand = new CreateAddressCommand();
}
public async Task <ActionResult <int> > Create(CreateAddressCommand command)
{
return(await Mediator.Send(command));
}
public async Task Create_Two_Addresses_For_New_User_Should_Return_Two_Addresses()
{
var registerCommand = new RegisterCommand()
{
FirstName = "FirstNameTest",
LastName = "LastNameTest",
CompanyName = "TestCompany",
Email = "*****@*****.**",
ConfirmEmail = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
UserDetailsDto user = await AuthHelper.SignUp(_httpClient, registerCommand);
var address1 = new CreateAddressCommand()
{
UserId = user.Id,
Alias = "Warszawa 100",
FirstName = user.FirstName,
Lastname = user.LastName,
Place = "Warszawa",
PostCode = "00-001",
Street = "test",
BuildingNumber = "100",
ApartmentNumber = "",
Phone = "000-000-000",
Email = user.Email,
};
var address2 = new CreateAddressCommand()
{
UserId = user.Id,
Alias = "Warszawa 12a/4",
FirstName = user.FirstName,
Lastname = user.LastName,
Place = "Warszawa",
PostCode = "00-002",
Street = "test2",
BuildingNumber = "12A",
ApartmentNumber = "4",
Phone = "000-000-000",
Email = user.Email
};
var createdAddress1 = await _httpClient.PostAsync <CreateAddressCommand, AddressDetailsDto>
($"api/users/{user.Id}/addresses", address1);
var createdAddress2 = await _httpClient.PostAsync <CreateAddressCommand, AddressDetailsDto>
($"api/users/{user.Id}/addresses", address2);
var addresses = await _httpClient.GetAsync <List <AddressDto> >($"api/users/{user.Id}/addresses");
Assert.Equal(2, addresses.Count);
Assert.Equal(address1.Alias, createdAddress1.Alias);
Assert.Equal(address1.Email, createdAddress1.Email);
Assert.Equal(address1.Phone, createdAddress1.Phone);
Assert.Equal(address1.UserId, createdAddress1.UserId);
Assert.Equal(address2.Alias, createdAddress2.Alias);
Assert.Equal(address2.Email, createdAddress2.Email);
Assert.Equal(address2.Phone, createdAddress2.Phone);
Assert.Equal(address2.UserId, createdAddress2.UserId);
}
public async Task Update_Address_Should_Return_Status_Code_204()
{
var registerCommand = new RegisterCommand()
{
FirstName = "FirstNameTestAddressUpdate",
LastName = "LastNameTestAddressUpdate",
CompanyName = "TestCompanyAddressUpdate",
Email = "*****@*****.**",
ConfirmEmail = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
UserDetailsDto user = await AuthHelper.SignUp(_httpClient, registerCommand);
var newAddress = new CreateAddressCommand()
{
UserId = user.Id,
Alias = "My home",
FirstName = user.FirstName,
Lastname = user.LastName,
Place = "Warszawa",
PostCode = "00-005",
Street = "test54",
BuildingNumber = "12A",
Phone = "000-000-000",
Email = user.Email
};
var createdAddress = await _httpClient.PostAsync <CreateAddressCommand, AddressDetailsDto>
($"/api/users/{user.Id}/addresses", newAddress);
var addressToUpdate = new ChangeAddressCommand()
{
Id = createdAddress.Id,
Alias = "updated 999",
Email = "*****@*****.**",
Phone = "123-123-123",
BuildingNumber = "999A",
ApartmentNumber = "99",
Place = "Place updated",
Street = "Street updated",
FirstName = user.FirstName,
Lastname = user.LastName,
PostCode = "00-321"
};
var messagePut = await _httpClient.PutAsync($"/api/users/{user.Id}/addresses/{createdAddress.Id}", addressToUpdate);
var updatedAddress = await _httpClient.GetAsync <AddressDetailsDto>($"api/users/{user.Id}/addresses/{addressToUpdate.Id}");
Assert.Equal(HttpStatusCode.NoContent, messagePut.StatusCode);
Assert.Equal(addressToUpdate.Id, updatedAddress.Id);
Assert.Equal(addressToUpdate.Alias, updatedAddress.Alias);
Assert.Equal(addressToUpdate.Email, updatedAddress.Email);
Assert.Equal(addressToUpdate.Phone, updatedAddress.Phone);
Assert.Equal(addressToUpdate.BuildingNumber, updatedAddress.BuildingNumber);
Assert.Equal(addressToUpdate.ApartmentNumber, updatedAddress.ApartmentNumber);
Assert.Equal(addressToUpdate.Place, updatedAddress.Place);
Assert.Equal(addressToUpdate.FirstName, updatedAddress.FirstName);
Assert.Equal(addressToUpdate.Lastname, updatedAddress.LastName);
Assert.Equal(addressToUpdate.Street, updatedAddress.Street);
Assert.Equal(addressToUpdate.PostCode, updatedAddress.PostCode);
}
