public void IsLocationOrDateUpdated_LocationAndDateAreTheSame_ReturnsFalse()
{
// arrange
var latitude = 0.45;
var longitude = 0.67;
var date = new DateTime(2020, 02, 02);
var runDb = new RunDb()
{
Latitude = latitude,
Longitude = longitude,
Date = date
};
var request = new RunUpdateRequest()
{
Latitude = latitude,
Longitude = longitude,
Date = date
};
// act
var result = _runService.IsLocationOrDateUpdated(runDb, request);
// assert
result.Should().BeFalse();
}
public void IsLocationOrDateUpdated_LongitudeAndLatitudeDifferencesLessThanTolerance_ReturnsFalse()
{
// arrange
var latitude = 0.45;
var longitude = 0.67;
var newLatitude = 0.45009; // LocationTolerance = 0.0001
var newLongitude = 0.67009; // LocationTolerance = 0.0001
var date = new DateTime(2020, 02, 02);
var runDb = new RunDb()
{
Latitude = latitude,
Longitude = longitude,
Date = date
};
var request = new RunUpdateRequest()
{
Latitude = newLatitude,
Longitude = newLongitude,
Date = date
};
// act
var result = _runService.IsLocationOrDateUpdated(runDb, request);
// assert
result.Should().BeFalse();
}
public void UpdateRunAsync_LocationUpdated_RunIsUpdated_WeatherServiceIsCalled()
{
// arrange
var date = DateTime.Now;
var latitude = 3.44;
var longitude = 67.456;
var newDate = new DateTime(1999, 1, 2);
var newLatitude = 56.44;
var newLongitude = 34.456;
var newForecast = "new forecast";
var request = new RunUpdateRequest()
{
Date = newDate,
Distance = 1,
Time = 2,
Latitude = newLatitude,
Longitude = newLongitude
};
var userId = Guid.NewGuid().ToString();
var rundId = 3;
var dbRuns = new RunDb[]
{
new RunDb()
{
Id = rundId,
UserId = userId,
Date = date,
Latitude = latitude,
Longitude = longitude,
WeatherConditions = "good forecast"
}
};
_mockDbContext.CreateDbSetMock(x => x.Runs, dbRuns);
_mockWeatherService.Setup(x => x.GetWeatherConditionsAsync(
newDate, newLatitude, newLongitude)).Returns(Task.FromResult(newForecast));
// act
var result = _runService.UpdateRunAsync(userId, rundId, request).Result;
// assert
result.Id.Should().Be(rundId);
result.UserId.Should().Be(userId);
result.Date.Should().Be(request.Date);
result.Distance.Should().Be(request.Distance);
result.Time.Should().Be(request.Time);
result.Latitude.Should().Be(request.Latitude);
result.Longitude.Should().Be(request.Longitude);
result.WeatherConditions.Should().Be(newForecast);
_mockWeatherService.Verify(x => x.GetWeatherConditionsAsync(
newDate, newLatitude, newLongitude), Times.Once);
_mockDbContext.Verify(x => x.Update(It.IsAny <RunDb>()), Times.Once);
_mockDbContext.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public void IsLocationOrDateUpdated_DateIsUpdated_ReturnsTrue()
{
// arrange
var latitude = 0.45;
var longitude = 0.67;
var date = new DateTime(2020, 02, 02);
var newDate = new DateTime(2010, 01, 01);
var runDb = new RunDb()
{
Latitude = latitude,
Longitude = longitude,
Date = date
};
var request = new RunUpdateRequest()
{
Latitude = latitude,
Longitude = longitude,
Date = newDate
};
// act
var result = _runService.IsLocationOrDateUpdated(runDb, request);
// assert
result.Should().BeTrue();
}
public void UpdateRunAsync_CorrectRunId_IncorrectUserId_ThrowsNoFoundException()
{
// arrange
var request = new RunUpdateRequest()
{
Date = DateTime.Now,
Distance = 1,
Time = 2,
Latitude = 3,
Longitude = 4
};
var userId = Guid.NewGuid().ToString();
var rundId = 3;
var dbRuns = new RunDb[]
{
new RunDb()
{
Id = rundId,
UserId = Guid.NewGuid().ToString()
}
};
_mockDbContext.CreateDbSetMock(x => x.Runs, dbRuns);
// act
var result = Assert.ThrowsAsync <JoggingTrackerNotFoundException>(
() => _runService.UpdateRunAsync(userId, rundId, request)).Result;
// assert
result.Message.Should().Be(ErrorMessages.RunNotFound);
_mockDbContext.Verify(x => x.Update(It.IsAny <RunDb>()), Times.Never);
_mockDbContext.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Never);
}
public async Task <ActionResult> UpdateCurrentUserRunAsync(int runId, [FromBody] RunUpdateRequest request)
{
var currentUserId = HttpContext.GetCurrentUserId();
var result = await _runService.UpdateRunAsync(currentUserId, runId, request);
return(StatusCode(StatusCodes.Status200OK, result));
}
public void UpdateRunAsync_LocationAndDateAreNotChanged_RunIsUpdated_WeatherServiceIsNotCalled()
{
// arrange
var date = DateTime.Now;
var latitude = 3.44;
var longitude = 67.456;
var request = new RunUpdateRequest()
{
Date = date,
Distance = 1,
Time = 2,
Latitude = latitude,
Longitude = longitude
};
var userId = Guid.NewGuid().ToString();
var rundId = 3;
var dbRuns = new RunDb[]
{
new RunDb()
{
Id = rundId,
UserId = userId,
Date = date,
Latitude = latitude,
Longitude = longitude,
WeatherConditions = "good forecast"
}
};
_mockDbContext.CreateDbSetMock(x => x.Runs, dbRuns);
// act
var result = _runService.UpdateRunAsync(userId, rundId, request).Result;
// assert
result.Id.Should().Be(rundId);
result.UserId.Should().Be(userId);
result.Date.Should().Be(dbRuns[0].Date.Date);
result.Distance.Should().Be(request.Distance);
result.Time.Should().Be(request.Time);
result.Latitude.Should().Be(dbRuns[0].Latitude);
result.Longitude.Should().Be(dbRuns[0].Longitude);
result.WeatherConditions.Should().Be(dbRuns[0].WeatherConditions);
_mockWeatherService.Verify(x => x.GetWeatherConditionsAsync(
It.IsAny <DateTime>(), It.IsAny <double>(), It.IsAny <double>()), Times.Never);
_mockDbContext.Verify(x => x.Update(It.IsAny <RunDb>()), Times.Once);
_mockDbContext.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public void UpdateRunAsync_InternalServerExceptionOnUpdate_ThrowsException()
{
// arrange
var date = DateTime.Now;
var latitude = 3.44;
var longitude = 67.456;
var request = new RunUpdateRequest()
{
Date = date,
Distance = 1,
Time = 2,
Latitude = latitude,
Longitude = longitude
};
var userId = Guid.NewGuid().ToString();
var rundId = 3;
var dbRuns = new RunDb[]
{
new RunDb()
{
Id = rundId,
UserId = userId,
Date = date,
Latitude = latitude,
Longitude = longitude,
WeatherConditions = "good forecast"
}
};
_mockDbContext.CreateDbSetMock(x => x.Runs, dbRuns);
var errorMessage = "error message";
_mockDbContext.Setup(x => x.Update(It.IsAny <RunDb>()))
.Throws(new Exception(errorMessage));
// act
var result = Assert.ThrowsAsync <JoggingTrackerInternalServerErrorException>(
() => _runService.UpdateRunAsync(userId, rundId, request)).Result;
// assert
var expectedErrorMessage = $"{ErrorMessages.RunSaveErrorMessage} : {errorMessage}";
result.Message.Should().Be(expectedErrorMessage);
_mockDbContext.Verify(x => x.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Never);
}
public async Task <RunDto> UpdateRunAsync(string userId,
int runId,
RunUpdateRequest request)
{
try
{
// search by userId too to prevent using not related user id as a parameter
var runDb = await _dbContext.Runs.FirstOrDefaultAsync(x => x.Id == runId &&
x.UserId == userId);
if (runDb == null)
{
throw new JoggingTrackerNotFoundException(ErrorMessages.RunNotFound);
}
if (IsLocationOrDateUpdated(runDb, request))
{
var newWeatherConditions = await _weatherService.GetWeatherConditionsAsync(request.Date,
request.Latitude,
request.Longitude);
runDb.WeatherConditions = newWeatherConditions;
}
_mapper.Map(request, runDb);
_dbContext.Update(runDb);
await _dbContext.SaveChangesAsync();
var response = _mapper.Map <RunDb, RunDto>(runDb);
return(response);
}
catch (JoggingTrackerNotFoundException)
{
throw;
}
catch (Exception ex)
{
throw new JoggingTrackerInternalServerErrorException(
$"{ErrorMessages.RunSaveErrorMessage} : {ex.Message}");
}
}
public void From_UpdateRunRequest_To_RunDb()
{
var updateRunRequest = new RunUpdateRequest()
{
Date = new DateTime(2020, 02, 16, 10, 10, 29), //Sunday
Distance = 5,
Time = 6,
Latitude = 7.4,
Longitude = 6.5,
};
var result = _mapper.Map <RunUpdateRequest, RunDb>(updateRunRequest);
result.Date.Should().Be(updateRunRequest.Date.Date);
result.Distance.Should().Be(updateRunRequest.Distance);
result.Time.Should().Be(updateRunRequest.Time);
result.Latitude.Should().Be(updateRunRequest.Latitude);
result.Longitude.Should().Be(updateRunRequest.Longitude);
}
public async Task <ActionResult> UpdateRunAsync(string userId, int runId, [FromBody] RunUpdateRequest request)
{
var result = await _runService.UpdateRunAsync(userId, runId, request);
return(StatusCode(StatusCodes.Status200OK, result));
}
protected bool IsLocationOrDateUpdated(RunDb runDb, RunUpdateRequest request)
{
return(runDb.Date != request.Date ||
Math.Abs(runDb.Latitude - request.Latitude) >= Constants.AppConstants.LocationTolerance ||
Math.Abs(runDb.Longitude - request.Longitude) > Constants.AppConstants.LocationTolerance);
}
public new bool IsLocationOrDateUpdated(RunDb runDb, RunUpdateRequest request)
{
return(base.IsLocationOrDateUpdated(runDb, request));
}
public void UserGetsRegistered_AddsRuns_UpdatesRun_RequestList_And_DeletesTheirRecord_RunShouldBeDeleted()
{
// user gets registered
var newUserRequest = new UserRegisterRequest()
{
UserName = "******",
Password = "******"
};
var httpCreateResponse = _client.PostAsync(_baseUri, ContentHelper.GetStringContent(newUserRequest)).Result;
httpCreateResponse.EnsureSuccessStatusCode();
var stringResponse = httpCreateResponse.Content.ReadAsStringAsync().Result;
var user = JsonConvert.DeserializeObject <UserDto>(stringResponse);
user.Id.Should().NotBeNull();
var newUserDb = _dbContext.Users.FirstOrDefault(x => x.Id == user.Id);
newUserDb.Should().NotBeNull();
// user authenticates
var token = GetUserToken(newUserRequest.UserName, newUserRequest.Password);
token.Should().NotBeNull();
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var newRun = new RunCreateRequest()
{
Date = new DateTime(2020, 2, 11),
Distance = 500,
Time = 500,
Latitude = 2,
Longitude = 2
};
var httpCreateRunResponse = _client.PostAsync(_baseRunsUri, ContentHelper.GetStringContent(newRun)).Result;
httpCreateRunResponse.EnsureSuccessStatusCode();
var createRunStringContent = httpCreateRunResponse.Content.ReadAsStringAsync().Result;
var createRunDtoResponse = JsonConvert.DeserializeObject <RunDto>(createRunStringContent);
createRunDtoResponse.UserId.Should().Be(newUserDb.Id);
createRunDtoResponse.Should().NotBeNull();
createRunDtoResponse.Date.Should().Be(newRun.Date);
createRunDtoResponse.Distance.Should().Be(newRun.Distance);
createRunDtoResponse.Time.Should().Be(newRun.Time);
createRunDtoResponse.Latitude.Should().Be(newRun.Latitude);
createRunDtoResponse.Longitude.Should().Be(newRun.Longitude);
var dbRun = _dbContext.Runs.FirstOrDefault(x => x.Id == createRunDtoResponse.Id);
dbRun.Should().NotBeNull();
// update run
var updateRunRequest = new RunUpdateRequest()
{
Date = new DateTime(2012, 2, 11),
Distance = 30,
Time = 12,
Latitude = 54,
Longitude = 45
};
var httpUpdateRunResponse = _client.PutAsync($"{_baseRunsUri}/{dbRun.Id}", ContentHelper.GetStringContent(updateRunRequest)).Result;
httpUpdateRunResponse.EnsureSuccessStatusCode();
var updateRunStringContent = httpUpdateRunResponse.Content.ReadAsStringAsync().Result;
var updateRunDtoResponse = JsonConvert.DeserializeObject <RunDto>(updateRunStringContent);
updateRunDtoResponse.UserId.Should().Be(newUserDb.Id);
updateRunDtoResponse.Should().NotBeNull();
updateRunDtoResponse.Date.Should().Be(updateRunRequest.Date);
updateRunDtoResponse.Distance.Should().Be(updateRunRequest.Distance);
updateRunDtoResponse.Time.Should().Be(updateRunRequest.Time);
updateRunDtoResponse.Latitude.Should().Be(updateRunRequest.Latitude);
updateRunDtoResponse.Longitude.Should().Be(updateRunRequest.Longitude);
// get the list of runs
var httpGetRunsListResponse = _client.GetAsync($"{_baseRunsUri}/").Result;
httpGetRunsListResponse.EnsureSuccessStatusCode();
var getRunsListStringContent = httpGetRunsListResponse.Content.ReadAsStringAsync().Result;
var getRunsListDtoResponse = JsonConvert.DeserializeObject <PagedResult <RunDto> >(getRunsListStringContent);
getRunsListDtoResponse.Items.Count.Should().Be(1);
// user deletes their own record
var httpDeleteResponse = _client.DeleteAsync($"{_baseUri}/me").Result;
httpDeleteResponse.StatusCode.Should().Be(StatusCodes.Status204NoContent);
// user is not in the database anymore
var deletedUser = _dbContext.Users.FirstOrDefault(x => x.Id == user.Id);
deletedUser.Should().BeNull();
var deletetRunDb = _dbContext.Runs.FirstOrDefault(x => x.Id == createRunDtoResponse.Id);
deletetRunDb.Should().BeNull();
}
