public async Task TestCancelAsync_WithIncorrectWorkoutId_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var user = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var workoutActivity = new WorkoutActivity()
{
Id = "activityId1",
Name = "activityName1",
Icon = "iconUrl1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var paymentMethod = new PaymentMethod()
{
Id = "activityId1",
Name = "activityName1",
PaymentInAdvance = false,
};
await this.paymentMethodsRepository.AddAsync(paymentMethod);
await this.paymentMethodsRepository.SaveChangesAsync();
WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
{
Activity = workoutActivity.Name,
Duration = 15,
Location = "location1",
MaxParticipants = 10,
Price = 10.50m,
Time = DateTime.Now.AddDays(1),
PaymentMethods = new List <string>()
{
paymentMethod.Name
},
};
await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);
var createdWorkout = await this.workoutsRepository.All()
.FirstOrDefaultAsync();
var incorrectWorkoutId = "incorrect" + createdWorkout.Id;
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.workoutsService.CancelAsync(incorrectWorkoutId, testUserId));
}
public async Task TestUpdateAsync_WithIncorrectId_ShouldThrowNullRefEx()
{
var testActivityId = "testActivityId";
var incorrectActivityId = "incorrectActivityId";
var testInitialName = "testInitialName";
var testUpdatedName = "testUpdatedName";
var testInitialDescription = "testInitialDescription";
var testUpdatedDescription = "testUpdatedDescription";
var workoutActivity = new WorkoutActivity
{
Id = testActivityId,
Name = testInitialName,
Description = testInitialDescription,
Icon = "ActivityIconUrl",
};
await this.workoutActivitiesRepository.AddAsync(workoutActivity);
await this.workoutActivitiesRepository.SaveChangesAsync();
var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
{
Id = incorrectActivityId,
Name = testUpdatedName,
Description = testUpdatedDescription,
};
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel));
}
public async Task <WorkoutActivityDetailsViewModel> CreateAsync(WorkoutActivityServiceModel workoutActivityServiceModel)
{
var checkActivityExists = this.workoutActivitiesRepository.All()
.FirstOrDefault(x => x.Name == workoutActivityServiceModel.Name);
if (checkActivityExists != null)
{
return(AutoMapper.Mapper.Map <WorkoutActivityDetailsViewModel>(checkActivityExists));
}
var workoutActivity = new WorkoutActivity
{
Name = workoutActivityServiceModel.Name,
Description = workoutActivityServiceModel.Description,
Icon = workoutActivityServiceModel.Icon,
};
await this.workoutActivitiesRepository.AddAsync(workoutActivity);
await this.workoutActivitiesRepository.SaveChangesAsync();
var workoutActivityDetailsViewModel = AutoMapper.Mapper.Map <WorkoutActivityDetailsViewModel>(workoutActivity);
return(workoutActivityDetailsViewModel);
}
public async Task TestUpdateAsync_WithIncorrectUser_ShouldThrowArgEx()
{
var testUserId = "testUserId1";
var incorrectUserId = "incorrectUserId";
var testCertificateId = "testCertificateId";
var testIssuedBy = "TestOrganization1";
var testActivityName = "activityName1";
var updatedIssuedById = "TestOrganization2";
var workoutActivity = new WorkoutActivity()
{
Id = "testId1",
Name = testActivityName,
Icon = "testIconUrl1",
Description = "TestDescription1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var testUser = new TrainConnectedUser()
{
Id = testUserId,
};
var incorrectTestUser = new TrainConnectedUser()
{
Id = incorrectUserId,
};
await this.usersRepository.AddAsync(testUser);
await this.usersRepository.AddAsync(incorrectTestUser);
await this.usersRepository.SaveChangesAsync();
var certificate = new Certificate()
{
Id = testCertificateId,
TrainConnectedUserId = testUserId,
ActivityId = "testId1",
Description = "TestDescriptionForTesting1",
IssuedBy = testIssuedBy,
Activity = workoutActivity,
IssuedOn = DateTime.Now.AddDays(-5),
};
await this.certificatesRepository.AddAsync(certificate);
await this.certificatesRepository.SaveChangesAsync();
var certificateEditInputModel = AutoMapper.Mapper.Map <CertificateEditInputModel>(certificate);
certificateEditInputModel.IssuedBy = updatedIssuedById;
await Assert.ThrowsAsync <ArgumentException>(async() => await this.certificatesService.UpdateAsync(certificateEditInputModel, incorrectUserId));
}
public async Task TestUpdateAsync_WithTestData_ShouldUpdateCertificate()
{
var testUserId = "testUserId1";
var testCertificateId = "testCertificateId";
var testIssuedBy = "TestOrganization1";
var testActivityName = "activityName1";
var updatedIssuedById = "TestOrganization2";
var workoutActivity = new WorkoutActivity()
{
Id = "testId1",
Name = testActivityName,
Icon = "testIconUrl1",
Description = "TestDescription1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var testUser = new TrainConnectedUser()
{
Id = testUserId,
};
await this.usersRepository.AddAsync(testUser);
await this.usersRepository.SaveChangesAsync();
var certificate = new Certificate()
{
Id = testCertificateId,
TrainConnectedUserId = testUserId,
ActivityId = "testId1",
Description = "TestDescriptionForTesting1",
IssuedBy = testIssuedBy,
Activity = workoutActivity,
IssuedOn = DateTime.Now.AddDays(-5),
};
await this.certificatesRepository.AddAsync(certificate);
await this.certificatesRepository.SaveChangesAsync();
var certificateEditInputModel = AutoMapper.Mapper.Map <CertificateEditInputModel>(certificate);
certificateEditInputModel.IssuedBy = updatedIssuedById;
await this.certificatesService.UpdateAsync(certificateEditInputModel, testUserId);
var actualResult = await this.certificatesRepository.All()
.Where(u => u.TrainConnectedUserId == testUserId)
.FirstOrDefaultAsync();
Assert.Equal(updatedIssuedById, actualResult.IssuedBy);
}
public async Task TestDeleteAsync_WithIncorrectUserId_ShouldThrowArgEx()
{
var testUserId = "testUserId1";
var incorrectUserId = "incorrectUserId";
var testCertificateId = "testCertificateId";
var testIssuedBy = "TestOrganization1";
var testActivityName = "activityName1";
var workoutActivity = new WorkoutActivity()
{
Id = "testId1",
Name = testActivityName,
Icon = "testIconUrl1",
Description = "TestDescription1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var testUser = new TrainConnectedUser()
{
Id = testUserId,
};
var incorrectUser = new TrainConnectedUser()
{
Id = incorrectUserId,
};
await this.usersRepository.AddAsync(testUser);
await this.usersRepository.AddAsync(incorrectUser);
await this.usersRepository.SaveChangesAsync();
var certificate = new Certificate()
{
Id = testCertificateId,
TrainConnectedUserId = testUserId,
ActivityId = "testId1",
Description = "TestDescriptionForTesting1",
IssuedBy = testIssuedBy,
Activity = workoutActivity,
IssuedOn = DateTime.Now.AddDays(-5),
};
await this.certificatesRepository.AddAsync(certificate);
await this.certificatesRepository.SaveChangesAsync();
Assert.NotEmpty(await this.certificatesRepository.All().ToArrayAsync());
await Assert.ThrowsAsync <ArgumentException>(async() => await this.certificatesService.DeleteAsync(testCertificateId, incorrectUserId));
}
public async Task Handle(ActivityCompleted notification, CancellationToken cancellationToken)
{
Workout workout = await GetWorkoutAsync(notification.UserId, notification.WorkoutId);
var activity = new Activity(notification.WorkoutId, notification.ActivityId)
{
WorkoutStarted = workout.StartDateTime,
ExerciseId = notification.ExerciseId,
Added = notification.Added,
UserId = notification.UserId,
Sets = notification.Sets?.ToArray(),
Rating = notification.Rating
};
await _activityTableHandler.InsertOrReplace(activity);
var exercises = await _exerciseRepository.GetAllExercisesAsync();
var workoutActivity = new WorkoutActivity
{
ActivityId = notification.ActivityId,
Added = notification.Added,
ExerciseId = notification.ExerciseId,
SetCount = notification.Sets.Count(),
ExerciseName = exercises.SingleOrDefault(s => s.Id == notification.ExerciseId).Name,
};
var activities = workout.Activities.ToList();
var existingIndex = activities.Select((x, idx) => new { x.ActivityId, idx })
.Where(p => p.ActivityId == notification.ActivityId)
.Select(p => p.idx + 1)
.FirstOrDefault() - 1;
if (existingIndex == -1)
{
activities.Add(workoutActivity);
}
else
{
activities[existingIndex] = workoutActivity;
}
workout.Activities = activities.ToArray();
workout.ActivityCount = workout.Activities.Count();
workout.Version = notification.Version;
await _workoutTableHandler.InsertOrReplace(workout);
}
public async Task TestUpdateAsync_WithDuplicateName_ShouldThrowInvOpEx()
{
var testActivityId = "testActivityId";
var testInitialName = "testInitialName";
var testUpdatedName = "testUpdatedName";
var testInitialDescription = "testInitialDescription";
var testUpdatedDescription = "testUpdatedDescription";
await this.workoutActivitiesRepository.AddAsync(new WorkoutActivity()
{
Id = "testId",
Name = testUpdatedName,
Description = testUpdatedDescription,
});
await this.workoutActivitiesRepository.SaveChangesAsync();
var workoutActivity = new WorkoutActivity
{
Id = testActivityId,
Name = testInitialName,
Description = testInitialDescription,
Icon = "ActivityIconUrl",
};
await this.workoutActivitiesRepository.AddAsync(workoutActivity);
await this.workoutActivitiesRepository.SaveChangesAsync();
var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
{
Id = testActivityId,
Name = testUpdatedName,
Description = testUpdatedDescription,
};
await Assert.ThrowsAsync <InvalidOperationException>(async() => await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel));
}
public async Task TestUpdateAsync_WithTestData_ShouldUpdateWorkoutActivity()
{
var testActivityId = "testActivityId";
var testInitialName = "testInitialName";
var testUpdatedName = "testUpdatedName";
var testInitialDescription = "testInitialDescription";
var testUpdatedDescription = "testUpdatedDescription";
var workoutActivity = new WorkoutActivity
{
Id = testActivityId,
Name = testInitialName,
Description = testInitialDescription,
Icon = "ActivityIconUrl",
};
await this.workoutActivitiesRepository.AddAsync(workoutActivity);
await this.workoutActivitiesRepository.SaveChangesAsync();
var workoutActivityEditInputModel = new WorkoutActivityEditInputModel()
{
Id = testActivityId,
Name = testUpdatedName,
Description = testUpdatedDescription,
};
await this.workoutActivitiesService.UpdateAsync(workoutActivityEditInputModel);
var result = await this.workoutActivitiesRepository.All()
.Where(wa => wa.Id == testActivityId)
.FirstOrDefaultAsync();
Assert.Equal(testUpdatedName, result.Name);
Assert.Equal(testUpdatedDescription, result.Description);
}
public async Task TestCancelAsync_WithTestData_ShouldCancelWorkout()
{
var testUserId = "testUserId";
var testUserName = "******";
var user = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var workoutActivity = new WorkoutActivity()
{
Id = "activityId1",
Name = "activityName1",
Icon = "iconUrl1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var paymentMethod = new PaymentMethod()
{
Id = "activityId1",
Name = "activityName1",
PaymentInAdvance = false,
};
await this.paymentMethodsRepository.AddAsync(paymentMethod);
await this.paymentMethodsRepository.SaveChangesAsync();
WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
{
Activity = workoutActivity.Name,
Duration = 15,
Location = "location1",
MaxParticipants = 10,
Price = 10.50m,
Time = DateTime.Now.AddDays(1),
PaymentMethods = new List <string>()
{
paymentMethod.Name
},
};
await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);
var initialResult = await this.workoutsRepository.All()
.ToArrayAsync();
Assert.NotEmpty(initialResult);
var workoutId = initialResult.FirstOrDefault().Id;
await this.workoutsService.CancelAsync(workoutId, testUserId);
var finalResult = await this.workoutsRepository.All()
.ToArrayAsync();
Assert.Empty(finalResult);
}
public async Task TestGetCancelDetailsAsync_WithTestData_ShouldReturnWorkoutDetails()
{
var testUserId = "testUserId";
var testUserName = "******";
var user = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var workoutActivity = new WorkoutActivity()
{
Id = "activityId1",
Name = "activityName1",
Icon = "iconUrl1",
};
await this.workoutActivityRepository.AddAsync(workoutActivity);
await this.workoutActivityRepository.SaveChangesAsync();
var paymentMethod = new PaymentMethod()
{
Id = "activityId1",
Name = "activityName1",
PaymentInAdvance = false,
};
await this.paymentMethodsRepository.AddAsync(paymentMethod);
await this.paymentMethodsRepository.SaveChangesAsync();
WorkoutCreateInputModel workoutCreateInputModel = new WorkoutCreateInputModel()
{
Activity = workoutActivity.Name,
Duration = 15,
Location = "location1",
MaxParticipants = 10,
Price = 10.50m,
Time = DateTime.Now.AddDays(1),
PaymentMethods = new List <string>()
{
paymentMethod.Name
},
};
await this.workoutsService.CreateAsync(workoutCreateInputModel, testUserId);
var expectedResult = await this.workoutsRepository.All()
.Where(w => w.CoachId == testUserId)
.To <WorkoutCancelViewModel>()
.FirstOrDefaultAsync();
var workoutId = expectedResult.Id;
var actualResult = await this.workoutsService.GetCancelDetailsAsync(workoutId, testUserId);
Assert.Equal(expectedResult.ActivityName, actualResult.ActivityName);
Assert.Equal(expectedResult.Duration, actualResult.Duration);
Assert.Equal(expectedResult.Price, actualResult.Price);
Assert.Equal(expectedResult.Location, actualResult.Location);
Assert.Equal(expectedResult.MaxParticipants, actualResult.MaxParticipants);
Assert.Equal(expectedResult.Time, actualResult.Time);
Assert.Equal(expectedResult.Id, actualResult.Id);
}
