public void All_WhenShowingView_ThenAllShoesAreDisplayed()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new ShoeController(dbContext);
IndexSetup(dbContext, controller);
// Act
var result = controller.All();
// Assert
var viewModels = result.CastModel<ICollection<ShoeDetailViewModel>>();
AssertAllShoesAreShown(viewModels,dbContext.Shoes);
foreach (var viewModel in viewModels)
{
var matchingShoe = dbContext.Shoes.First(s => s.ShoeId == viewModel.ShoeId);
AssertCurrentUser(matchingShoe);
AssertShoeName(viewModel, matchingShoe);
AssertFirstUsed(viewModel, matchingShoe);
AssertLastUsed(viewModel, matchingShoe);
AssertShoesWithWorkoutsCannotBeDeleted(viewModel, matchingShoe);
AssertShoesWithWorkoutsCannotBeDeleted(viewModel, matchingShoe);
AssertDistanceUsedIsSumOfWorkouts(viewModel, matchingShoe);
AssertPercentRemainigIsRatioOfDistanceToWorkouts(viewModel, matchingShoe);
AssertExpirationDateIsEmptyWhenTheShoeIsNoLongerUsed(viewModel, matchingShoe);
}
}
public void Create_WhenSavingValidWorkout_ThenWorkoutIsSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext()
.WithShoe("Some show", _currentUserId);
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithValidModelState();
var workoutOnView = controller.Create().CastModel<EditWorkoutViewModel>();
workoutOnView.Distance = 1.2m;
workoutOnView.Name = "my name";
workoutOnView.WorkoutDate = DateTime.Today.AddDays(-4);
workoutOnView.ShoeUsedId = long.Parse(workoutOnView.AvailableShoes.First().Value);
// Act
controller.Create(workoutOnView);
// Assert
Assert.That(dbContext.Workouts.Count(), Is.EqualTo(1));
Assert.That(dbContext.Workouts.First().UserId, Is.EqualTo(_currentUserId));
Assert.That(dbContext.Workouts.First().Distance, Is.EqualTo(workoutOnView.Distance));
Assert.That(dbContext.Workouts.First().Name, Is.EqualTo(workoutOnView.Name));
Assert.That(dbContext.Workouts.First().ShoeUsed.ShoeId, Is.EqualTo(workoutOnView.ShoeUsedId));
Assert.That(dbContext.Workouts.First().WorkoutDate, Is.EqualTo(workoutOnView.WorkoutDate));
}
public void MapMyRunAuthorizationCallback_WhenUserIsNotConnected_ThenTheAuthorizationDataIsSaved()
{
// Arrange
const string authorizationCode = "some code";
const string accessToken = "access token";
const int mmfUserId = 34;
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithFitnessProvider(1, "MapMyFitness");
var api = Substitute.For<MapMyFitnessApi>();
var accessTokenResponse = new AccessTokenResponse { access_token = accessToken };
api.GetAccessToken(authorizationCode).Returns(accessTokenResponse);
var currentUser = new User { id = mmfUserId };
api.GetCurrentUser(accessTokenResponse.access_token).Returns(currentUser);
var controller = new FitnessProviderController(dbContext, api)
.WithAuthenticatedUser("some user", _currentUserId);
// Act
controller.MapMyRunAuthorizationCallback("some status", authorizationCode);
// Assert
var savedData = dbContext.UserFitnessProviders
.First(f => f.UserId == _currentUserId && f.FitnessProvider.Name == "MapMyFitness");
AssertMapMyFitnessAuthorizationDataIsSaved(savedData, authorizationCode, accessToken, mmfUserId, dbContext);
}
public void All_WhenShowingView_ThenAllWorkoutsAreDisplayed()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new WorkoutController(dbContext);
IndexSetup(dbContext, controller);
// Act
var result = controller.All();
// Assert
var viewModels = result.CastModel<ICollection<Workout>>();
Assert.That(viewModels.Count, Is.EqualTo(dbContext.Workouts.Count()));
foreach (var viewModel in viewModels)
{
var matchingWorkout = dbContext.Workouts.First(s => s.WorkoutId == viewModel.WorkoutId);
Assert.That(matchingWorkout.Distance, Is.EqualTo(matchingWorkout.Distance));
Assert.That(matchingWorkout.Name, Is.EqualTo(matchingWorkout.Name));
Assert.That(matchingWorkout.WorkoutDate, Is.EqualTo(matchingWorkout.WorkoutDate));
Assert.That(matchingWorkout.ShoeUsed, Is.SameAs(matchingWorkout.ShoeUsed));
}
}
public void Create_WhenSavingValidShoe_ThenShoeIsSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
var shoeOnView = controller.Create().CastModel<Shoe>();
// Act
controller.Create(shoeOnView);
// Assert
Assert.That(dbContext.Shoes.Count(), Is.EqualTo(1));
Assert.That(dbContext.Shoes.First().UserId,Is.EqualTo(_currentUserId));
}
public void Create_WhenSavingInValidWorkout_ThenWorkoutIsNotSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithInvalidModelState();
var workoutOnView = controller.Create().CastModel<EditWorkoutViewModel>();
// Act
controller.Create(workoutOnView);
// Assert
Assert.That(dbContext.Workouts.Count(), Is.EqualTo(0));
}
public void Create_WhenShowingView_ThenNewShoeHasDefaults()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user",_currentUserId);
// Act
var result = controller.Create();
// Assert
var modelData = result.CastModel<Shoe>();
Assert.That(modelData.UserId,Is.EqualTo(_currentUserId));
Assert.That(modelData.FirstUsed,Is.EqualTo(DateTime.Today));
}
public void Edit_WhenShowingView_ThenTheMatchingShoeIsShown()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext()
.WithShoe("some shoe", _currentUserId);
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
var shoeId = dbContext.Shoes.Select(s => s.ShoeId).First();
// Act
var result = controller.Edit(shoeId);
// Assert
var viewResult = (ViewResult) result;
var shoe = viewResult.CastModel<Shoe>();
Assert.That(shoe.ShoeId,Is.EqualTo(shoeId));
}
public void Delete_WhenShowingView_ThenTheMatchingWorkoutIsShown()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext()
.WithWorkout("some run", _currentUserId);
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
var workoutId = dbContext.Workouts.Select(s => s.WorkoutId).First();
// Act
var result = controller.Delete(workoutId);
// Assert
var viewResult = (ViewResult)result;
var workout = viewResult.CastModel<Workout>();
Assert.That(workout.WorkoutId, Is.EqualTo(workoutId));
}
private static void AssertMapMyFitnessAuthorizationDataIsSaved(UserFitnessProvider savedData,
string authorizationCode,
string accessToken,
int mmfUserId,
FakeShoeTrackerDbContext dbContext)
{
Assert.That(savedData.AuthorizationToken, Is.EqualTo(authorizationCode));
Assert.That(savedData.AccessToken, Is.EqualTo(accessToken));
Assert.That(savedData.ExternalUserId, Is.EqualTo(mmfUserId.ToString()));
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
}
public void DeleteConfirmed_WhenDeletingInValidShoe_ThenNothingHappes()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithValidModelState();
const int shoeId = -1;
// Act
controller.DeleteConfirmed(shoeId);
// Assert
Assert.That(dbContext.Shoes.Count(), Is.EqualTo(0));
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
}
public void Edit_WhenShowingView_ThenTheMatchingWorkoutIsShown()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext()
.WithShoe("Foo", _currentUserId)
.WithShoe("Bar", _currentUserId)
.WithShoe("Other", "some other user")
.WithWorkout("some workout", _currentUserId,shoeName:"Foo");
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
var workout = dbContext.Workouts.First();
var workoutId = workout.WorkoutId;
// Act
var result = controller.Edit(workoutId);
// Assert
var viewResult = (ViewResult)result;
var workoutViewModel = viewResult.CastModel<EditWorkoutViewModel>();
Assert.That(workoutViewModel.WorkoutId, Is.EqualTo(workoutId));
Assert.That(workoutViewModel.Name, Is.EqualTo(workout.Name));
Assert.That(workoutViewModel.WorkoutDate, Is.EqualTo(workout.WorkoutDate));
Assert.That(workoutViewModel.Distance, Is.EqualTo(workout.Distance));
Assert.That(workoutViewModel.ShoeUsedId, Is.EqualTo(workout.ShoeUsed.ShoeId));
}
public void Edit_WhenSavingValidWorkflow_ThenWorkflowIsSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithShoe("foo", _currentUserId)
.WithWorkout("some workout", _currentUserId, shoeName: "foo");
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithValidModelState();
var workoutId = dbContext.Workouts.Select(s => s.WorkoutId).First();
var workoutOnView = ((ViewResult)controller.Edit(workoutId)).CastModel<EditWorkoutViewModel>();
workoutOnView.Name = "some other name";
workoutOnView.Distance = 55m;
workoutOnView.WorkoutDate = DateTime.Today.AddDays(5);
// Act
controller.Edit(workoutOnView);
// Assert
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
var savedWorkout = dbContext.Workouts.First(w => w.WorkoutId == workoutId);
Assert.That(savedWorkout.Name,Is.EqualTo(workoutOnView.Name));
Assert.That(savedWorkout.Distance,Is.EqualTo(workoutOnView.Distance));
Assert.That(savedWorkout.WorkoutDate,Is.EqualTo(workoutOnView.WorkoutDate));
}
public void Edit_WhenSavingInValidWorkout_ThenWorkoutIsNotSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithShoe("foo", _currentUserId)
.WithWorkout("some workout", _currentUserId, shoeName: "foo");
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithInvalidModelState();
var workoutId = dbContext.Workouts.Select(s => s.WorkoutId).First();
var workoutOnView = ((ViewResult)controller.Edit(workoutId)).CastModel<EditWorkoutViewModel>();
// Act
controller.Edit(workoutOnView);
// Assert
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(0));
}
public void SyncMapMyFitnessWorkouts_WhenUserIsNotConnected_ThenTheUserIsRedirectedToWorkouts()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var api = Substitute.For<MapMyFitnessApi>();
var controller = new FitnessProviderController(dbContext, api)
.WithAuthenticatedUser("some user", _currentUserId);
// Act
var result = controller.SyncMapMyFitnessWorkouts();
// Assert
AssertRedirectedToWorkoutIndex(result);
}
public void DeleteConfirmed_WhenDeleting_ThenTheShoeIsRemovedFromTheDatabase()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithShoe("foo", _currentUserId)
.WithShoe("other", _currentUserId);
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithValidModelState();
var shoeId = dbContext.Shoes.Select(s => s.ShoeId).First();
// Act
controller.DeleteConfirmed(shoeId);
// Assert
Assert.That(dbContext.Shoes.Count(),Is.EqualTo(1));
Assert.That(dbContext.Shoes.First().Name,Is.EqualTo("other"));
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
}
private static void AssertAllWorkoutsAreSaved(FakeShoeTrackerDbContext dbContext)
{
Assert.That(dbContext.Workouts.Count(), Is.EqualTo(4));
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
}
public void Edit_WhenSavingValidShoe_ThenShoeIsSaved()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithShoe("foo", _currentUserId);
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId)
.WithValidModelState();
var shoeId = dbContext.Shoes.Select(s => s.ShoeId).First();
var shoeOnView = ((ViewResult)controller.Edit(shoeId)).CastModel<Shoe>();
shoeOnView.Name = "some other name";
// Act
controller.Edit(shoeOnView);
// Assert
Assert.That(dbContext.NumerOfTimesSaveChangesCalled, Is.EqualTo(1));
}
private static void AssertWorkoutDetails(FakeShoeTrackerDbContext dbContext, List<domain.fitness_providers.mapmyfitness.models.Workout> mmfWorkouts)
{
foreach (var workout in dbContext.Workouts)
{
var matchingMmfWorkout = mmfWorkouts.FirstOrDefault(w => w._links.self[0].id == workout.ExternalWorkoutId);
if (matchingMmfWorkout == null)
{
Assert.Fail("Unable to find MapMyFitness workout with Id '{0}",workout.ExternalWorkoutId);
}
AssertWorkoutIsForCurrentUser(workout);
AssertWorkoutIsForMapMyFitness(workout);
AssertWorkoutNameMatches(workout, matchingMmfWorkout);
AssertWorkoutDateMatches(workout, matchingMmfWorkout);
AssertDistanceMatches(workout, matchingMmfWorkout);
}
}
public void Edit_WhenShowingViewWithInvalidShoeId_ThenNotFoundResult()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext();
var controller = new ShoeController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
const int shoeId = -1;
// Act
var result = controller.Edit(shoeId);
// Assert
Assert.That(result,Is.InstanceOf<HttpNotFoundResult>());
}
public void SyncMapMyFitnessWorkouts_WhenUserIsConnected_ThenWorkoutsAreSynchronized()
{
// Arrange
const string acessToken = "some token";
const int externalUserId = 23;
var today = DateTime.Now;
var yesterday = DateTime.Now.AddDays(-1);
var dayBeforeYesterday = DateTime.Now.AddDays(-2);
var lastWeek = DateTime.Now.AddDays(-7);
var lastMonth = DateTime.Now.AddMonths(-1);
var dbContext = new FakeShoeTrackerDbContext();
dbContext
.WithFitnessProvider(1, "MapMyFitness")
.WithUserFitnessProvider("MapMyFitness", _currentUserId,externalUserId:externalUserId.ToString(),accessToken:acessToken)
.WithShoe("current shoe",_currentUserId,firstUsedDate:dayBeforeYesterday.Date)
.WithShoe("previous shoe",_currentUserId,firstUsedDate:lastWeek.Date.AddDays(-1),lastUsedDate:dayBeforeYesterday.Date)
;
var api = Substitute.For<MapMyFitnessApi>()
.WithGetWorkoutsByUserStubbed(externalUserId, acessToken)
.WithWorkout(externalUserId,acessToken,name:"today's workout",distanceInMiles:5,workoutDate:today,activityType:"16")
.WithWorkout(externalUserId,acessToken,name:"today's swim",distanceInMiles:5,workoutDate:today,activityType:"1") // should not be imported
.WithWorkout(externalUserId, acessToken, name: "today's bike ride", distanceInMiles: 5, workoutDate: today, activityType: "2")// should not be imported
.WithWorkout(externalUserId, acessToken, name: "today's saunter", distanceInMiles: 5, workoutDate: today, activityType: "3")// should not be imported
.WithWorkout(externalUserId, acessToken, name: "yesterday's workout", distanceInMiles: 6, workoutDate: yesterday, activityType: "136")
.WithWorkout(externalUserId, acessToken, name: "last week's workout", distanceInMiles: 7, workoutDate: lastWeek, activityType: "91")
.WithWorkout(externalUserId, acessToken, name: "last month's workout", distanceInMiles: 8, workoutDate: lastMonth, activityType: "16")
;
var controller = new FitnessProviderController(dbContext, api)
.WithAuthenticatedUser("some user", _currentUserId);
// Act
var result = controller.SyncMapMyFitnessWorkouts();
// Assert
AssertRedirectedToWorkoutIndex(result);
AssertAllWorkoutsAreSaved(dbContext);
DateTime? lastImportedAt = null;
var mmfWorkouts = api.GetWorkoutsByUser(externalUserId, acessToken, lastImportedAt)
.ToList();
AssertWorkoutDetails(dbContext, mmfWorkouts);
AssertShoeMatches(dbContext, "today's workout","current shoe");
AssertShoeMatches(dbContext, "yesterday's workout", "current shoe");
AssertShoeMatches(dbContext, "last week's workout","previous shoe");
AssertShoeMatches(dbContext, "last month's workout",null);
}
public void Create_WhenShowingView_ThenNewWorkoutHasDefaults()
{
// Arrange
var dbContext = new FakeShoeTrackerDbContext()
.WithShoe("Foo", _currentUserId)
.WithShoe("Bar", _currentUserId)
.WithShoe("Other", "some other user");
var controller = new WorkoutController(dbContext)
.WithAuthenticatedUser("some user", _currentUserId);
// Act
var result = controller.Create();
// Assert
var modelData = result.CastModel<EditWorkoutViewModel>();
Assert.That(modelData.WorkoutDate, Is.EqualTo(DateTime.Today));
Assert.That(modelData.AvailableShoes.Count(), Is.EqualTo(2));
}
