public void GetByIdReturnsDto()
{
// arrange
var id = Guid.NewGuid();
var model = new Bike {
Id = id, Colour = ExpectedColour, Model = ExpectedModel, Name = ExpectedName
};
var expected = new BikeDto {
Colour = ExpectedColour, Model = ExpectedModel, Name = ExpectedName
};
this.mockQueryRepository.Setup(repo => repo.GetById(id))
.Returns(model)
.Verifiable();
this.mockBikeConverter.Setup(converter => converter.ToDto(model))
.Returns(expected)
.Verifiable();
var sut = this.CreateSut();
// act
var actual = sut.GetById(id);
// assert
actual.Should().BeEquivalentTo(expected);
this.mockQueryRepository.Verify(repo => repo.GetById(id), Times.Once);
this.mockBikeConverter.Verify(converter => converter.ToDto(model), Times.Once);
}
public void UpdateBike_Updates_Bike()
{
var testId = 1;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid(),
BikeModelId = Guid.NewGuid(),
BikeColorId = testId,
WheelSizeId = testId,
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.UpdateBike(dto);
mockRepo.Verify(r => r.Update(
It.Is <BikeEntity>(b =>
b.IsActive == true &&
b.BikeColorId == dto.BikeColorId &&
b.BikeModelId == dto.BikeModelId &&
b.WheelSizeId == dto.WheelSizeId &&
b.PurchaseDate.Date == DateTime.UtcNow.Date &&
b.RemovedFromInventoryDate == null)),
Times.Once);
}
public async Task <IActionResult> PutBike(int id, BikeDto bike)
{
Bike b = BikeDto.FromBikeDto(bike);
if (id != b.Id)
{
return(BadRequest());
}
_context.Entry(b).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BikeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void CompareObjectProperties_Returns_4_Results()
{
var startIntId = 1;
var endIntId = 2;
var bike = new BikeEntity
{
BikeModelId = Guid.NewGuid(),
BikeColorId = startIntId,
WheelSizeId = startIntId,
};
var dto = new BikeDto
{
IsActive = false,
BikeModelId = Guid.NewGuid(),
BikeColorId = endIntId,
WheelSizeId = endIntId,
CurrentStatusId = endIntId
};
var excludedProperties = new List <string> {
"id", "PurchaseDate", "RemovedFromInventoryDate"
};
var actual = objectInspectionService.GetDifferentPropertyValues(bike, dto, excludedProperties);
var expectedCount = 5; // amount of properties in dto
Assert.AreEqual(expectedCount, actual.Count());
}
public void UpdateBike(int id, BikeDto bikeDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var bikeinDb = _context.Bike.SingleOrDefault(b => b.Id == id);
if (bikeinDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Mapper.Map(bikeDto, bikeinDb);
//customerinDb.Name = customerDto.Name;
//customerinDb.Dob = customerDto.Dob;
//customerinDb.IsSubscribedToNewsletter = customerDto.IsSubscribedToNewsletter;
//customerinDb.MembershipTypeId = customerDto.MembershipTypeId;
//customerinDb.mobno = customerDto.mobno;
//customerinDb.email = customerDto.email;
_context.SaveChanges();
}
public BikeDto CreateNewBike(BikeDto bikeDto)
{
var bikeToInsert = _mapper.Map <BikeEntity>(bikeDto);
var bike = _bikeRepository.Insert(bikeToInsert);
CreateHistoryItemForBike(bike.Id, Status.Prepping);
return(_mapper.Map <BikeDto>(bike));
}
public void CompareObjectProperties_Returns_Bike_With_DtosProperties()
{
var startIntId = 1;
var endIntId = 2;
var bike = new BikeEntity
{
BikeModelId = Guid.NewGuid(),
BikeColorId = startIntId,
WheelSizeId = startIntId,
};
var dto = new BikeDto
{
IsActive = false,
BikeModelId = Guid.NewGuid(),
BikeColorId = endIntId,
WheelSizeId = endIntId,
};
IEnumerable <ObjectPropertyDifference> expected = new List <ObjectPropertyDifference>
{
new ObjectPropertyDifference
{
PropertyName = "BikeColorId",
LeftValue = bike.BikeColorId.ToString(),
RightValue = dto.BikeColorId.ToString()
},
new ObjectPropertyDifference
{
PropertyName = "BikeModelId",
LeftValue = bike.BikeModelId.ToString(),
RightValue = dto.BikeModelId.ToString()
},
new ObjectPropertyDifference
{
PropertyName = "IsActive",
LeftValue = bike.IsActive.ToString(),
RightValue = dto.IsActive.ToString()
},
new ObjectPropertyDifference
{
PropertyName = "WheelSizeId",
LeftValue = bike.WheelSizeId.ToString(),
RightValue = dto.WheelSizeId.ToString()
},
};
var excludedProperties = new List <string> {
"id", "PurchaseDate", "LastCheckedOutDate", "LastReturnedDate", "LastRepairedDate", "RemovedFromInventoryDate"
};
var actual = objectInspectionService.GetDifferentPropertyValues(bike, dto, excludedProperties);
Assert.IsTrue(expected.All(e => actual.Any(a =>
a.PropertyName == e.PropertyName &&
a.LeftValue == e.LeftValue &&
a.RightValue == e.RightValue)));
}
public async Task <ActionResult <BikeDto> > PostBike(BikeDto bike)
{
Bike b = BikeDto.FromBikeDto(bike);
_context.Bikes.Add(b);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBike", new { id = bike.Id }, BikeDto.ToBikeDto(b)));
}
public async Task <ActionResult <BikeDto> > GetBike(int id)
{
var bike = await _context.Bikes.FindAsync(id);
if (bike == null)
{
return(NotFound());
}
return(BikeDto.ToBikeDto(bike));
}
public void CreateBike_Returns_BikeResource()
{
var expected = new BikeDto();
var request = new CreateBikeRequest();
mockMapper.Setup(m => m.Map <BikeDto>(It.IsAny <CreateBikeRequest>())).Returns(new BikeDto());
mockService.Setup(r => r.CreateNewBike(It.IsAny <BikeDto>())).Returns(expected);
mockService.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(expected);
var result = bikesController.CreateBike(request) as CreatedAtActionResult;
var actual = result.Value as BikeDto;
Assert.AreEqual(expected, actual);
}
public void CreateBike_Returns_Ok_Result()
{
var expected = new BikeDto();
var request = new CreateBikeRequest();
mockMapper.Setup(m => m.Map <BikeDto>(It.IsAny <CreateBikeRequest>())).Returns(new BikeDto());
mockService.Setup(r => r.CreateNewBike(It.IsAny <BikeDto>())).Returns(expected);
mockService.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(expected);
var result = bikesController.CreateBike(request) as CreatedAtActionResult;
Assert.NotNull(result);
Assert.AreEqual(201, result.StatusCode);
}
public async Task <ActionResult <BikeDto> > DeleteBike(int id)
{
var bike = await _context.Bikes.FindAsync(id);
if (bike == null)
{
return(NotFound());
}
_context.Bikes.Remove(bike);
await _context.SaveChangesAsync();
return(BikeDto.ToBikeDto(bike));
}
public void CreateNewBike_Calls_CreateHistoryItem_In_BikeHistoryService()
{
var entity = new BikeEntity();
var dto = new BikeDto();
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.Insert(It.IsAny <BikeEntity>())).Returns(entity);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.CreateNewBike(dto);
mockHistoryService.Verify(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>()), Times.Once);
}
public void CreateNewBike_Returns_BikeDto()
{
var entity = new BikeEntity();
var dto = new BikeDto();
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.Insert(It.IsAny <BikeEntity>())).Returns(entity);
mockMapper.Setup(m => m.Map <BikeDto>(entity)).Returns(dto);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
var actual = bikeService.CreateNewBike(dto);
Assert.AreEqual(dto, actual);
}
public void GetById_Returns_BikeDto()
{
var details = new BikeEntity();
var dto = new BikeDto();
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(details);
mockMapper.Setup(m => m.Map <BikeDto>(details))
.Returns(dto);
BikeDto actual = bikeService.GetById(Guid.NewGuid());
Assert.AreEqual(dto, actual);
}
public IHttpActionResult CreateBike(BikeDto bikeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var bike = Mapper.Map <BikeDto, Bike>(bikeDto);
_context.Bike.Add(bike);
_context.SaveChanges();
bikeDto.Id = bike.Id;
return(Created(new Uri(Request.RequestUri + "/" + bike.Id), bikeDto));
}
public void EditBike_Sends_BikeDto_To_Service()
{
var testId = 1;
var dto = new BikeDto
{
Id = Guid.NewGuid(),
BikeColorId = testId,
BikeModelId = Guid.NewGuid(),
CurrentStatusId = testId,
WheelSizeId = testId
};
mockMapper.Setup(m => m.Map <BikeDto>(It.IsAny <EditBikeRequest>())).Returns(dto);
bikesController.EditBike(new EditBikeRequest());
mockService.Verify(s => s.UpdateBike(dto), Times.Once);
}
public void UpdateBike(BikeDto bikeDto)
{
var bikeToUpdate = _bikeRepository.GetById(bikeDto.Id);
var historyItemId = CreateHistoryItemForBike(bikeToUpdate.Id, Status.Updated);
var excludedProperties = new List <string> {
"id"
};
var propertiesToUpdate = _inspectionService.GetDifferentPropertyValues(bikeToUpdate, bikeDto, excludedProperties);
CreateHistoryNoteForBikeUpdate(propertiesToUpdate, historyItemId);
bikeToUpdate.BikeColorId = bikeDto.BikeColorId;
bikeToUpdate.BikeModelId = bikeDto.BikeModelId;
bikeToUpdate.WheelSizeId = bikeDto.WheelSizeId;
_bikeRepository.Update(bikeToUpdate);
}
public void EditBike_Returns_Ok_Result()
{
var testId = 1;
var dto = new BikeDto
{
Id = Guid.NewGuid(),
BikeColorId = testId,
BikeModelId = Guid.NewGuid(),
CurrentStatusId = testId,
WheelSizeId = testId
};
mockMapper.Setup(m => m.Map <BikeDto>(It.IsAny <EditBikeRequest>())).Returns(dto);
var result = bikesController.EditBike(new EditBikeRequest()) as OkResult;
Assert.NotNull(result);
Assert.AreEqual(200, result.StatusCode);
}
public void RemoveBike_Calls_CreateHistoryItem_In_BikeHistoryItemService()
{
var testStatus = Status.Fixed;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid()
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.RemoveBike(dto.Id, testStatus);
mockHistoryService.Verify(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>()), Times.Once);
}
public void ChangeStatus_Calls_Update_In_Repo()
{
var testStatus = Status.Fixed;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid(),
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.ChangeStatus(dto.Id, testStatus);
mockRepo.Verify(r => r.Update(It.IsAny <BikeEntity>()), Times.Once);
}
public void ToDtoReturnsDtoWhenModelIsNotNull()
{
// arrange
var id = Guid.NewGuid();
var model = new Bike {
Id = id, Colour = ExpectedColour, Model = ExpectedModel, Name = ExpectedName
};
var expected = new BikeDto {
Colour = ExpectedColour, Model = ExpectedModel, Name = ExpectedName
};
var sut = CreateSut();
// act
var actual = sut.ToDto(model);
// assert
actual.Should().NotBeNull().And.BeEquivalentTo(expected);
}
public void GetByIdReturnsBadRequestWhenModelIsNull()
{
// arrange
var id = Guid.NewGuid();
BikeDto bikeDto = null;
this.mockBikeService.Setup(service => service.GetById(id))
.Returns(bikeDto)
.Verifiable();
var sut = this.CreateSut();
// act
var actual = sut.GetById(id);
// assert
actual.Should().BeOfType(typeof(BadRequestResult));
this.mockBikeService.Verify(service => service.GetById(id), Times.Once);
}
public void UpdateBike_Calls_CompareObjectProperties_In_ObjectInspectionService()
{
var testId = 1;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid(),
BikeModelId = Guid.NewGuid(),
BikeColorId = testId,
WheelSizeId = testId,
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.UpdateBike(dto);
mockInspectionService.Verify(r => r.GetDifferentPropertyValues(It.IsAny <BikeEntity>(), It.IsAny <BikeDto>(), It.IsAny <List <string> >()), Times.Once);
}
public void UpdateBike_Calls_CreateHistoryItem_In_HistoryService()
{
var testId = 1;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid(),
BikeModelId = Guid.NewGuid(),
BikeColorId = testId,
WheelSizeId = testId,
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.UpdateBike(dto);
mockHistoryService.Verify(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>()), Times.Once);
}
public ActionResult <IEnumerable <BikeDto> > GetAvailableBikes([FromQuery] string sortBy = "")
{
var rentals = _context.Rentals;
var bikes = _context.Bikes;
var availableBikes = bikes.Where(b => !rentals.Any(r => r.BikeId == b.Id));
switch (sortBy)
{
case "": break;
case "priceFirstHour": availableBikes = availableBikes.OrderBy(b => b.PriceFirstHour); break;
case "priceAdditionalHours": availableBikes = availableBikes.OrderBy(b => b.PricePerAdditionalHour); break;
case "purchaseDate": availableBikes = availableBikes.OrderByDescending(b => b.PurchaseDate); break;
default: return(NotFound("No such filter method found"));
}
return(BikeDto.ToBikeDto(availableBikes.ToList()));
}
public void RemoveBike_Updates_Bike()
{
var testStatus = Status.Fixed;
var bike = new BikeEntity();
var dto = new BikeDto
{
Id = Guid.NewGuid()
};
var historyItem = new BikeHistoryItemDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(bike);
mockHistoryService.Setup(r => r.CreateHistoryItem(It.IsAny <BikeHistoryItemDto>())).Returns(historyItem);
bikeService.RemoveBike(dto.Id, testStatus);
mockRepo.Verify(r => r.Delete(
It.Is <BikeEntity>(b =>
b.CurrentStatusId == (int)testStatus)),
Times.Once);
}
public async Task <IActionResult> UploadBlob([FromForm] BikeDto bikeDetails)
{
try
{
string attachmentUrl = string.Empty;
Bike bike = null;
if (!string.IsNullOrEmpty(bikeDetails.image.FileName))
{
string fileName = $"{Guid.NewGuid()}-{bikeDetails.image.FileName}";
string fileTempPath = @$ "{Path.GetTempPath()}{fileName}";
using var stream = new FileStream(fileTempPath, FileMode.Create, FileAccess.ReadWrite);
await bikeDetails.image.CopyToAsync(stream);
attachmentUrl = await _blobStorageService.UploadBlobAsync(stream, fileName);
}
if (!string.IsNullOrEmpty(attachmentUrl))
{
bike = new Bike()
{
Id = Guid.NewGuid().ToString(),
ImageUrl = attachmentUrl,
Brand = bikeDetails.Brand,
Location = bikeDetails.Location,
Model = bikeDetails.Model,
PricePerDay = bikeDetails.PricePerDay
};
}
var createdQuery = await _dataRepository.AddAsync(bike);
return(Ok(createdQuery));
}
catch (Exception e)
{
return(Ok("Transaction Failed"));
}
}
public ActionResult <IEnumerable <BikeDto> > GetBikes()
{
return(BikeDto.ToBikeDto(_context.Bikes.ToList()));
}
