public async Task AcceptOrder_WhenCalled_SendsPushNotification()
{
// Arrange
var taxiCompanyId = "someId";
var orderId = 1;
var taxiCompany = new TaxiCompany();
var order = new Order();
order.TaxiCompany = taxiCompany;
var ride = new Ride();
ride.StartDestination = new Address("", 1, "", 1);
ride.EndDestination = new Address("", 1, "", 1);
order.Rides = new List <Ride> {
ride
};
_unitOfWork.OrderRepository.FindByIDAsync(null).ReturnsForAnyArgs(order);
_unitOfWork.TaxiCompanyRepository.FindByIDAsync(null).ReturnsForAnyArgs(taxiCompany);
// Act
await _orderService.AcceptOrderAsync(taxiCompanyId, orderId);
// Assert
await _pushNotificationService.Received().SendAsync(Arg.Any <IPushNotification>());
}
/// <summary>
/// Adds a new taxi company to the database asynchronously and returns a JWT token wrapped in a response object.
/// </summary>
/// <remarks>
/// The generated token will only give access to endpoints which are available to taxi companies.
/// </remarks>
/// <param name="request">The required data needed to create the taxi company</param>
/// <returns>A RegisterResponseTaxiCompany object containing a valid JWT token</returns>
public async Task <RegisterResponseTaxiCompany> AddTaxiCompanyAsync(RegisterRequest request)
{
// Create the taxi company
var taxiCompany = new TaxiCompany
{
Name = request.Name,
PhoneNumber = request.PhoneNumber,
UserName = request.Email,
Email = request.Email
};
// Overwrite the taxi company with the one created and create a TaxiCompanyDto
await _unitOfWork.IdentityUserRepository.TransactionWrapper(async() =>
{
await _unitOfWork.IdentityUserRepository.AddIdentityUserAsync(taxiCompany, request.Password);
await _unitOfWork.IdentityUserRepository.AddToRoleAsync(taxiCompany, nameof(Customer));
});
var taxiCompanyDto = _mapper.Map <TaxiCompanyDto>(taxiCompany);
// Create the token, wrap it and return the response with the taxiCompanyDto
var token = _jwtService.GenerateJwtToken(taxiCompany.Id, taxiCompany.Email, nameof(TaxiCompany));
var response = new RegisterResponseTaxiCompany
{
Token = token,
TaxiCompany = taxiCompanyDto
};
return(response);
}
public async Task AcceptOrder_WhenCalled_ReturnsExpectedAcceptOrderResponse()
{
var taxiCompanyId = "someId";
var orderId = 1;
var orderDto = new OrderDto
{
Id = orderId,
Price = 200,
Rides = null,
Status = RideStatus.WaitingForAccept.ToString()
};
_mapper.Map <OrderDto>(null).ReturnsForAnyArgs(orderDto);
var order = new Order();
var taxicompany = new TaxiCompany();
_unitOfWork.OrderRepository.FindByIDAsync(null).ReturnsForAnyArgs(order);
_unitOfWork.TaxiCompanyRepository.FindByIDAsync(null).ReturnsForAnyArgs(taxicompany);
var expectedResponse = new AcceptOrderResponse {
Order = orderDto
};
var response = await _orderService.AcceptOrderAsync(taxiCompanyId, orderId);
Assert.That(response.Order, Is.EqualTo(expectedResponse.Order));
}
public async Task SetOrderToDebited_OrderExistsSoloRideAcceptedSaveChangesNotCalled_OrderIsStillAccepted()
{
var taxi = new TaxiCompany();
using (var context = _factory.CreateContext())
{
context.TaxiCompanies.Add(taxi);
context.SaveChanges();
}
var orderCreated = CreateTestOrderWithSoloRideInDatabase();
using (var context = _factory.CreateContext())
{
orderCreated.Status = OrderStatus.Accepted;
context.Orders.Update(orderCreated);
context.SaveChanges();
}
_uut.OrderRepository.SetOrderToDebited(orderCreated);
await _uut.SaveChangesAsync();
//Assert against database
using (var context = _factory.CreateContext())
{
Assert.That(context.Orders.Find(orderCreated.Id).Status, Is.EqualTo(OrderStatus.Debited));
}
}
public async Task AddTaxiCompanyAsync_AddingTaxiCompanySucceeds_ReturnsARegisterResponseTaxiCompanyThatContainsTheExpectedTaxiCompanyDto()
{
var request = new RegisterRequest
{
Email = "*****@*****.**",
Name = "Name",
Password = "******",
PasswordRepeated = "Qwer111!",
PhoneNumber = "12345678"
};
var taxiCompany = new TaxiCompany
{
Email = request.Email,
Name = request.Name,
PhoneNumber = request.PhoneNumber
};
_unitofWork.TaxiCompanyRepository.Add(null).ReturnsForAnyArgs(taxiCompany);
var taxiCompanyDto = new TaxiCompanyDto
{
Email = request.Email,
Name = request.Name,
PhoneNumber = request.PhoneNumber
};
_mapper.Map <TaxiCompanyDto>(null).ReturnsForAnyArgs(taxiCompanyDto);
var response = await _taxiCompanyService.AddTaxiCompanyAsync(request);
Assert.That(response.TaxiCompany, Is.EqualTo(taxiCompanyDto));
}
/// <summary>
/// edit a taxi company
/// </summary>
/// <param name="taxiCompany">taxi company object</param>
/// <returns>taxi company object</returns>
public TaxiCompany EditTaxiCompany(TaxiCompany taxiCompany)
{
Database db = Database.Open(DatabaseName);
var dbCommand =
"UPDATE TaxiCompany SET CompanyName = @1,CompanyLocation = @2, Description = @3 WHERE Id = @0";
db.QuerySingle(dbCommand, taxiCompany.Id, taxiCompany.CompanyName, taxiCompany.CompanyLocation,
taxiCompany.Description);
db.Close();
return(taxiCompany);
}
public void TestInitialize()
{
requestFrom = 0;
requestTo = 10;
companyPrce = 10;
taxiCompany = new TaxiCompany {
Price = 10
};
taxi = new Taxi {
Id = 1, Location = 0, Name = "Gagi", TaxiCompany = taxiCompany
};
}
public async Task SetOrderToAccepted_OrderExistsSoloRideWaitingForAcceptStatus_OrderIsAccepted()
{
var taxi = new TaxiCompany();
using (var context = _factory.CreateContext())
{
context.TaxiCompanies.Add(taxi);
context.SaveChanges();
}
var orderCreated = CreateTestOrderWithSoloRideInDatabase();
var order = _uut.OrderRepository.SetOrderToAccepted(orderCreated, taxi.Id);;
Assert.That(order.Status, Is.EqualTo(OrderStatus.Accepted));
}
/// <summary>
/// get a taxi company by id
/// </summary>
/// <param name="Id">id</param>
/// <returns>object of company</returns>
public TaxiCompany GetTaxiCompany(int Id)
{
Database db = Database.Open(DatabaseName);
string insertCommand = "SELECT * FROM TaxiCompany WHERE Id = @0";
var row = db.QuerySingle(insertCommand, Id);
db.Close();
if (row == null)
{
return(null);
}
var company = new TaxiCompany(row.Id, row.OwnerId, row.CompanyName, row.CompanyLocation, row.Description,
row.HasBeenValidated);
return(company);
}
private TaxiCompany addTaxiCompanyToTestDatabase(int balance = 0)
{
TaxiCompany taxiCompany = new TaxiCompany
{
Email = "*****@*****.**",
Name = "Name",
PhoneNumber = "12345678"
};
using (var context = _factory.CreateContext())
{
context.TaxiCompanies.Add(taxiCompany);
context.SaveChanges();
}
return(taxiCompany);
}
public async Task SetOrderToDebited_OrderExistsSoloRideNotWaitingForAcceptstatus_ThrowsException()
{
var taxi = new TaxiCompany();
using (var context = _factory.CreateContext())
{
context.TaxiCompanies.Add(taxi);
context.SaveChanges();
}
var order = new Order()
{
Status = OrderStatus.Debited
};
Assert.ThrowsAsync <UnexpectedStatusException>(async() => _uut.OrderRepository.SetOrderToAccepted(order, taxi.Id));;
}
/// <summary>
/// get all companies
/// </summary>
/// <returns>list of all companies</returns>
public List <TaxiCompany> GetAllCompanies()
{
Database db = Database.Open(DatabaseName);
string insertCommand = "SELECT * FROM TaxiCompany WHERE HasBeenValidated = 3";
var rows = db.Query(insertCommand);
db.Close();
List <TaxiCompany> companies = new List <TaxiCompany>();
foreach (var row in rows)
{
var company = new TaxiCompany(row.Id, row.OwnerId, row.CompanyName, row.CompanyLocation,
row.Description, row.HasBeenValidated);
companies.Add(company);
}
return(companies);
}
public async Task LoginTaxiCompanyAsync_LoginSucceeds_ReturnsLoginResponseThatContainsTheExpectedTaxiCompanyDto()
{
// Arrange
var request = new LoginRequest
{
Email = "*****@*****.**",
Password = "******"
};
var token = "Token";
_unitofWork.IdentityUserRepository.SignInAsync(null, null).ReturnsForAnyArgs(SignInResult.Success);
_jwtService.GenerateJwtToken(null, null, null).ReturnsForAnyArgs(token);
var taxiCompany = new TaxiCompany
{
Id = "Some Id",
Email = request.Email
};
_unitofWork.TaxiCompanyRepository.FindByEmail(null).ReturnsForAnyArgs(taxiCompany);
var taxiCompanyDto = new TaxiCompanyDto
{
Email = request.Email,
Name = "Some Name",
PhoneNumber = "12345678"
};
_mapper.Map <TaxiCompanyDto>(null).ReturnsForAnyArgs(taxiCompanyDto);
// Act
var response = await _taxiCompanyService.LoginTaxiCompanyAsync(request);
// Assert
Assert.That(response.TaxiCompany, Is.EqualTo(taxiCompanyDto));
}
public TaxiCompanyConsole()
{
_taxiCarCompany = new TaxiCompany <Car>();
_taxiCarCompany.Load();
_carList = _taxiCarCompany.GetCopy();
}
