public async Task TestGetForProcessingAsync_WithIncorrectData_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var testWithdrawalId = "testWithdrawalId";
var incorrectWithdrawalId = "incorrectWithdrawalId";
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 100.00m,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var withdrawal = new Withdrawal()
{
Amount = 10.05m,
Id = testWithdrawalId,
CreatedOn = DateTime.Now,
TrainConnectedUserId = testUserId,
TrainConnectedUser = user,
Status = StatusCode.Initiated,
};
await this.withdrawalsRepository.AddAsync(withdrawal);
await this.withdrawalsRepository.SaveChangesAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.withdrawalsService.GetForProcessingAsync(incorrectWithdrawalId));
}
public async Task TestAddAsync_WithSameUserAndBuddyId_ShouldThrowInvOpEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await this.buddiesService.AddAsync(testUserId, testUserId));
}
public async Task TestRemoveAsync_WithNoBuddyRelation_ShouldThrowArgEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <ArgumentException>(async() => await this.buddiesService.RemoveAsync(testBuddyId, testUserId));
}
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 TestCreateAsync_WithTestData_ShouldCreateWithdrawal()
{
var testUserId = "testUserId";
var testUserName = "******";
var withdrawalCreateInputModel = new WithdrawalCreateInputModel()
{
Amount = 15.45m,
AdditionalInstructions = "NoneOfTheAbove",
};
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 30.00m,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
await this.withdrawalsService.CreateAsync(withdrawalCreateInputModel, testUserId);
var result = await this.withdrawalsRepository.All()
.Where(u => u.TrainConnectedUserId == testUserId)
.FirstOrDefaultAsync();
Assert.NotNull(result);
Assert.True(result.Status == StatusCode.Initiated);
}
public async Task TestAddAsync_WithInCorrectBuddyId_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var incorrectBuddyId = "incorrectBuddyId";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.buddiesService.AddAsync(incorrectBuddyId, testUserId));
}
public async Task TestCreateAsync_WithoutWorkoutActivity_ShouldThrowNullRefEx()
{
var testUserId = "testUserId1";
var testCertificateId = "testCertificateId";
var testIssuedBy = "TestOrganization1";
var testActivityName = "activityName1";
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,
IssuedOn = DateTime.Now.AddDays(-5),
};
var certificateCreateInputModel = AutoMapper.Mapper.Map <CertificateCreateInputModel>(certificate);
certificateCreateInputModel.Activity = testActivityName;
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.certificatesService.CreateAsync(certificateCreateInputModel, testUserId));
}
protected override IdentityUserLogin <string> CreateUserLogin(TrainConnectedUser user, UserLoginInfo login) =>
new IdentityUserLogin <string>
{
UserId = user.Id,
ProviderKey = login.ProviderKey,
LoginProvider = login.LoginProvider,
ProviderDisplayName = login.ProviderDisplayName,
};
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));
}
protected override IdentityUserClaim <string> CreateUserClaim(TrainConnectedUser user, Claim claim)
{
var identityUserClaim = new IdentityUserClaim <string> {
UserId = user.Id
};
identityUserClaim.InitializeFromClaim(claim);
return(identityUserClaim);
}
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 TestProcessAsync_WithTestData_ShouldProcessWithdrawal()
{
var testUserId = "testUserId";
var testAdminId = "testAdminId";
var testWithdrawalId = "testWithdrawalId";
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 100.00m,
};
var adminUser = new TrainConnectedUser()
{
Id = testAdminId,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.AddAsync(adminUser);
await this.usersRepository.SaveChangesAsync();
var withdrawal = new Withdrawal()
{
Amount = 10.05m,
Id = testWithdrawalId,
CreatedOn = DateTime.Now,
TrainConnectedUserId = testUserId,
};
await this.withdrawalsRepository.AddAsync(withdrawal);
await this.withdrawalsRepository.SaveChangesAsync();
var inputModel = new WithdrawalProcessInputModel()
{
Amount = 10.05m,
Id = testWithdrawalId,
Status = true,
TrainConnectedUserId = testUserId,
};
await this.withdrawalsService.ProcessAsync(inputModel, testAdminId);
var expectedWithdrawalStatus = "Approved";
var actualWithdrawalStatus = await this.withdrawalsRepository.All()
.Where(w => w.Id == testWithdrawalId)
.Select(s => s.Status.ToString())
.FirstOrDefaultAsync();
Assert.Equal(expectedWithdrawalStatus, actualWithdrawalStatus);
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
// Get the information about the user from the external login provider
var info = await this.signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
this.ErrorMessage = "Error loading external login information during confirmation.";
return(this.RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (this.ModelState.IsValid)
{
var user = new TrainConnectedUser {
UserName = this.Input.Email,
Email = this.Input.Email,
FirstName = info.Principal.Identity.Name.Split(" ").ToArray().FirstOrDefault(),
LastName = info.Principal.Identity.Name.Split(" ").ToArray().LastOrDefault(),
PhoneNumber = "0123 456 789",
};
var result = await this.userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await this.userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await this.signInManager.SignInAsync(user, isPersistent : false);
this.logger.LogInformation(
"User created an account using {Name} provider.",
info.LoginProvider);
return(this.LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
}
this.LoginProvider = info.LoginProvider;
this.ReturnUrl = returnUrl;
return(this.Page());
}
public async Task SeedAsync(TrainConnectedDbContext dbContext, IServiceProvider serviceProvider)
{
var userManager = serviceProvider.GetRequiredService <UserManager <TrainConnectedUser> >();
var adminUser = new TrainConnectedUser()
{
UserName = GlobalConstants.AdministratorUserName,
FirstName = GlobalConstants.AdministratorFirstName,
LastName = GlobalConstants.AdministratorLastName,
Email = GlobalConstants.AdministratorEmail,
PhoneNumber = GlobalConstants.AdministratorPhoneNumber,
};
await SeedAdminAsync(userManager, adminUser);
}
protected override IdentityUserToken <string> CreateUserToken(
TrainConnectedUser user,
string loginProvider,
string name,
string value)
{
var token = new IdentityUserToken <string>
{
UserId = user.Id,
LoginProvider = loginProvider,
Name = name,
Value = value,
};
return(token);
}
public async Task TestProcessAsync_WithIncorrectUser_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var incorrectTestUserId = "incorrectTestUserId";
var testAdminId = "testAdminId";
var testWithdrawalId = "testWithdrawalId";
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 100.00m,
};
var adminUser = new TrainConnectedUser()
{
Id = testAdminId,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.AddAsync(adminUser);
await this.usersRepository.SaveChangesAsync();
var withdrawal = new Withdrawal()
{
Amount = 10.05m,
Id = testWithdrawalId,
CreatedOn = DateTime.Now,
TrainConnectedUserId = incorrectTestUserId,
};
await this.withdrawalsRepository.AddAsync(withdrawal);
await this.withdrawalsRepository.SaveChangesAsync();
var inputModel = new WithdrawalProcessInputModel()
{
Amount = 10.05m,
Id = testWithdrawalId,
Status = true,
TrainConnectedUserId = incorrectTestUserId,
};
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.withdrawalsService.ProcessAsync(inputModel, testAdminId));
}
public async Task TestRemoveRoleAsync_WithIncorrectRole_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var testIncorrectRoleName = "testIncorrectRoleName";
var user = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.usersService.RemoveRoleAsync(testIncorrectRoleName, testUserId));
}
public async Task TestGetDetailsAsync_WithCorrectData_ShouldReturnBuddyDetails()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersBuddiesRepository.AddAsync(new TrainConnectedUsersBuddies()
{
TrainConnectedUserId = testUserId,
TrainConnectedUser = testUser,
TrainConnectedBuddyId = testBuddyId,
TrainConnectedBuddy = testBuddyUser,
});
await this.usersRepository.SaveChangesAsync();
await this.usersBuddiesRepository.SaveChangesAsync();
var expectedResult = await this.usersBuddiesRepository.All()
.Where(u => u.TrainConnectedUserId == testUserId)
.Where(b => b.TrainConnectedBuddyId == testBuddyId)
.FirstOrDefaultAsync();
var actualResult = await this.buddiesService.GetDetailsAsync(testBuddyId, testUserId);
Assert.Equal(expectedResult.TrainConnectedBuddyId, actualResult.Id);
}
public async Task TestRemoveAsync_WithCorrectData_ShouldRemoveBuddy()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersBuddiesRepository.AddAsync(new TrainConnectedUsersBuddies()
{
TrainConnectedUserId = testUserId,
TrainConnectedUser = testUser,
TrainConnectedBuddyId = testBuddyId,
TrainConnectedBuddy = testBuddyUser,
});
await this.usersRepository.SaveChangesAsync();
await this.usersBuddiesRepository.SaveChangesAsync();
await this.buddiesService.RemoveAsync(testBuddyId, testUserId);
var result = await this.usersBuddiesRepository.All().ToArrayAsync();
var resultCount = result.Count();
Assert.Equal(0, resultCount);
}
public async Task TestGetDetailsAsync_WithIncorrectBuddyData_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var incorrectBuddyId = "incorrectBuddyId";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersBuddiesRepository.AddAsync(new TrainConnectedUsersBuddies()
{
TrainConnectedUserId = testUserId,
TrainConnectedUser = testUser,
TrainConnectedBuddyId = testBuddyId,
TrainConnectedBuddy = testBuddyUser,
});
await this.usersRepository.SaveChangesAsync();
await this.usersBuddiesRepository.SaveChangesAsync();
var expectedResult = await this.usersBuddiesRepository.All()
.Where(u => u.TrainConnectedUserId == testUserId)
.Where(b => b.TrainConnectedBuddyId == testBuddyId)
.FirstOrDefaultAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.buddiesService.GetDetailsAsync(incorrectBuddyId, testUserId));
}
public async Task TestGetUserBalanceAsync_WithIncorrectUser_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var incorrectUserId = "incorrectUserId";
var testUserName = "******";
var testUserBalance = 13480037.63m;
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = testUserBalance,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.withdrawalsService.GetUserBalanceAsync(incorrectUserId));
}
public async Task TestGetUserBalanceAsync_WithTestData_ShouldReturnUserBalance()
{
var testUserId = "testUserId";
var testUserName = "******";
var testUserBalance = 13480037.63m;
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = testUserBalance,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var result = await this.withdrawalsService.GetUserBalanceAsync(testUserId);
Assert.Equal(testUserBalance, result);
}
public async Task TestGetUserPendingWithdrawalsAsync_WithIncorrectUser_ShouldThrowNullRefEx()
{
var testUserId = "testUserId";
var incorrectUserId = "incorrectUserId";
var testUserName = "******";
var testUserBalance = 13480037.63m;
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = testUserBalance,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var withdrawals = new List <Withdrawal>()
{
new Withdrawal
{
Amount = 100.10m,
Id = "testWithdrawalId1",
CreatedOn = DateTime.Now,
TrainConnectedUserId = testUserId,
Status = StatusCode.Initiated,
},
};
foreach (var w in withdrawals)
{
await this.withdrawalsRepository.AddAsync(w);
}
await this.withdrawalsRepository.SaveChangesAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.withdrawalsService.GetUserPendingWithdrawalsBalance(incorrectUserId));
}
public async Task TestGetCoachDetailsAsync_WithInCorrectData_ShouldThrowNullRefEx()
{
var testCoachId = "testCoachId";
var testCoachUserName = "******";
var incorrectCoachUserName = "******";
var testCoach = new TrainConnectedUser()
{
Id = testCoachId,
UserName = testCoachUserName,
};
await this.usersRepository.AddAsync(testCoach);
await this.usersRepository.SaveChangesAsync();
var expectedResult = await this.usersRepository.All()
.Where(x => x.UserName == testCoachUserName)
.FirstOrDefaultAsync();
await Assert.ThrowsAsync <NullReferenceException>(async() => await this.buddiesService.GetCoachDetailsAsync(incorrectCoachUserName));
}
public async Task TestGetForProcessingAsync_WithTestData_ShouldReturnWithdrawal()
{
var testUserId = "testUserId";
var testWithdrawalId = "testWithdrawalId";
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 100.00m,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
var withdrawal = new Withdrawal()
{
Amount = 10.05m,
Id = testWithdrawalId,
CreatedOn = DateTime.Now,
TrainConnectedUserId = testUserId,
TrainConnectedUser = user,
Status = StatusCode.Initiated,
};
await this.withdrawalsRepository.AddAsync(withdrawal);
await this.withdrawalsRepository.SaveChangesAsync();
var expectedResult = await this.withdrawalsRepository.All()
.To <WithdrawalsProcessingViewModel>()
.FirstOrDefaultAsync();
var actualResult = await this.withdrawalsService.GetForProcessingAsync(testWithdrawalId);
Assert.Equal(expectedResult.TrainConnectedUserId, actualResult.TrainConnectedUserId);
Assert.Equal(expectedResult.Amount, actualResult.Amount);
}
public async Task TestCreateAsync_WithNegativeAmount_ShouldThrowInvOpEx()
{
var testUserId = "testUserId";
var testUserName = "******";
var withdrawalCreateInputModel = new WithdrawalCreateInputModel()
{
Amount = -15.45m,
AdditionalInstructions = "NoneOfTheAbove",
};
var user = new TrainConnectedUser()
{
Id = testUserId,
Balance = 30.00m,
UserName = testUserName,
};
await this.usersRepository.AddAsync(user);
await this.usersRepository.SaveChangesAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await this.withdrawalsService.CreateAsync(withdrawalCreateInputModel, testUserId));
}
public async Task TestGetCoachDetailsAsync_WithCorrectData_ShouldReturnCoach()
{
var testCoachId = "testCoachId";
var testCoachUserName = "******";
var testCoach = new TrainConnectedUser()
{
Id = testCoachId,
UserName = testCoachUserName,
};
await this.usersRepository.AddAsync(testCoach);
await this.usersRepository.SaveChangesAsync();
var expectedResult = await this.usersRepository.All()
.Where(x => x.UserName == testCoachUserName)
.FirstOrDefaultAsync();
var actualResult = await this.buddiesService.GetCoachDetailsAsync(testCoachUserName);
Assert.Equal(expectedResult.Id, actualResult.Id);
Assert.Equal(expectedResult.UserName, actualResult.UserName);
}
public async Task TestAddAsync_WithCorrectData_ShouldAddBuddy()
{
var testUserId = "testUserId";
var testUserName = "******";
var testBuddyId = "testBuddyId";
var testBuddyName = "testBuddyName";
var testUser = new TrainConnectedUser()
{
Id = testUserId,
UserName = testUserName,
};
await this.usersRepository.AddAsync(testUser);
var testBuddyUser = new TrainConnectedUser()
{
Id = testBuddyId,
UserName = testBuddyName,
};
await this.usersRepository.AddAsync(testBuddyUser);
await this.usersRepository.SaveChangesAsync();
await this.buddiesService.AddAsync(testBuddyId, testUserId);
var result = await this.usersBuddiesRepository.All()
.Where(u => u.TrainConnectedUserId == testUserId)
.Where(b => b.TrainConnectedBuddyId == testBuddyId)
.FirstOrDefaultAsync();
Assert.NotNull(result);
Assert.Equal(result.TrainConnectedUserId, testUserId);
Assert.Equal(result.TrainConnectedBuddyId, testBuddyId);
}
private static async Task SeedAdminAsync(UserManager <TrainConnectedUser> userManager, TrainConnectedUser adminUser)
{
var result = await userManager.CreateAsync(adminUser, GlobalConstants.AdministratorPassword);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(adminUser, GlobalConstants.AdministratorRoleName);
}
}
