public async Task DeleteByUserIdAndRecipeIdAsync_WithNonExistentUserIdAndExistentRecipeId_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userFavoriteRecipeRepository = new EfRepository <UserFavoriteRecipe>(context);
var userFavoriteRecipeService = new UserFavoriteRecipeService(userFavoriteRecipeRepository);
await this.SeedDataAsync(context);
var nonExistentUserId = Guid.NewGuid().ToString();
var recipeId = context.Recipes.First(x => x.Title == "Recipe 1").Id;
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await userFavoriteRecipeService
.DeleteByUserIdAndRecipeIdAsync(nonExistentUserId, recipeId);
});
}
public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "CategoryService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedDataAsync(context);
var categoryRepository = new EfDeletableEntityRepository <Category>(context);
var categoryService = new CategoryService(categoryRepository);
var categoryServiceModel = categoryRepository.All().First().To <CategoryServiceModel>();
categoryServiceModel.Title = "New Title";
// Act
var result = await categoryService.EditAsync(categoryServiceModel);
// Assert
Assert.True(result, errorMessagePrefix + " " + "Returns false.");
}
public async Task DeleteByUserIdAndRecipeIdAsync_WithExistentUserIdAndRecipeId_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "UserFavoriteRecipeService DeleteByUserIdAndRecipeIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userFavoriteRecipeRepository = new EfRepository <UserFavoriteRecipe>(context);
var userFavoriteRecipeService = new UserFavoriteRecipeService(userFavoriteRecipeRepository);
await this.SeedDataAsync(context);
var userId = context.Users.First(x => x.FullName == "User 1").Id;
var recipeId = context.Recipes.First(x => x.Title == "Recipe 1").Id;
// Act
var result = await userFavoriteRecipeService
.DeleteByUserIdAndRecipeIdAsync(userId, recipeId);
// Assert
Assert.True(result, errorMessagePrefix + " " + "Returns false.");
}
public async Task IsInAdministratorRoleAsync_WithNonExistentUserId_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userManager = this.GetUserManagerMock();
userManager
.Setup(x => x.IsInRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.ReturnsAsync(true);
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var administratorService = new AdministratorService(this.configuration, userManager.Object, userRepository);
var nonExistentUserId = Guid.NewGuid().ToString();
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await administratorService.IsInAdministratorRoleAsync(nonExistentUserId);
});
}
public async Task AddAdditionalInfoAsync_WithCorrectData_ShouldSuccessfullyAdd()
{
var errorMessagePrefix = "UserService AddAdditionalInfoAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userRepository = new EfDeletableEntityRepository <ApplicationUser>(context);
var userService = this.GetUserService(userRepository, context);
await this.SeedDataAsync(context);
var userId = context.Users.First().Id;
var userAdditionalInfoServiceModel = new UserAdditionalInfoServiceModel()
{
Biography = "Biography",
ProfilePhoto = "ProfilePhoto",
Lifestyle = context.Lifestyles.First().To <LifestyleServiceModel>(),
};
userAdditionalInfoServiceModel.Allergies.Add(new UserAllergenServiceModel()
{
Allergen = context.Allergens.First().To <AllergenServiceModel>(),
});
// Act
await userService.AddAdditionalInfoAsync(userId, userAdditionalInfoServiceModel);
var actualResult = userRepository.All().First(x => x.Id == userId);
var expectedResult = userAdditionalInfoServiceModel;
// Assert
Assert.True(actualResult.HasAdditionalInfo, errorMessagePrefix + " " + "HasAdditionalInfo is not returned properly.");
Assert.True(expectedResult.Biography == actualResult.Biography, errorMessagePrefix + " " + "Biography is not returned properly.");
Assert.True(expectedResult.ProfilePhoto == actualResult.ProfilePhoto, errorMessagePrefix + " " + "ProfilePhoto is not returned properly.");
Assert.True(expectedResult.Lifestyle.Id == actualResult.Lifestyle.Id, errorMessagePrefix + " " + "Lifestyle is not returned properly.");
Assert.True(expectedResult.Allergies.First().Allergen.Id == actualResult.Allergies.First().Allergen.Id, errorMessagePrefix + " " + "Allergen is not returned properly.");
}
public async Task AddReservationAsync_WithCorrectData_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "ReservationsService AddReservationAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationRepository = new EfDeletableEntityRepository <Reservation>(context);
var reservationsService = this.GetReservationService(reservationRepository, context);
var seeder = new ReservationsServiceTestsSeeder();
await seeder.SeedDataForAddAsyncMethodAsync(context);
var reservation = new Reservation
{
UserId = context.Users.First().Id,
StartDate = new DateTime(2020, 4, 4),
EndDate = new DateTime(2020, 4, 8),
Adults = 2,
Kids = 1,
ReservationStatusId = context.ReservationStatuses.First().Id,
PaymentTypeId = context.PaymentTypes.First().Id,
TotalAmount = 1000,
PricePerDay = 250,
TotalDays = 4,
AdvancedPayment = 300,
ReservationRooms = new List <ReservationRoom> {
new ReservationRoom {
RoomId = context.Rooms.First().Id
}
},
};
// Act
var result = await reservationsService.AddReservationAsync(reservation);
// Assert
Assert.True(result, errorMessagePrefix + " " + "Returns false.");
}
public async Task EditAsync_FunctionsProperly()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var promoCodeRepository = new EfDeletableEntityRepository <PromoCode>(context);
var promoCodeService = new PromoCodeService(promoCodeRepository);
var promoCodesTestSeeder = new PromoCodesTestSeeder();
await promoCodesTestSeeder.SeedPromoCodesAsync(context);
var validPromoCodeCreateInputModel = new PromoCodeCreateInputModel()
{
Id = "FirstId",
Name = "FirstChanged",
};
var invalidNamePromoCodeCreateInputModel = new PromoCodeCreateInputModel()
{
Id = "SecondId",
Name = "FirstChanged",
};
var exceptionPromoCodeCreateInputModel = new PromoCodeCreateInputModel()
{
Id = "invalid",
Name = "invalid",
};
var shouldBeTrue = await promoCodeService.EditAsync(validPromoCodeCreateInputModel);
var shouldBeFalse = await promoCodeService.EditAsync(invalidNamePromoCodeCreateInputModel);
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await promoCodeService.EditAsync(exceptionPromoCodeCreateInputModel);
});
}
public async Task AddReservationAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationRepository = new EfDeletableEntityRepository <Reservation>(context);
var reservationsService = this.GetReservationService(reservationRepository, context);
var seeder = new ReservationsServiceTestsSeeder();
await seeder.SeedDataForAddAsyncMethodAsync(context);
var reservation = new Reservation
{
UserId = null,
StartDate = new DateTime(2020, 4, 4),
EndDate = new DateTime(2020, 4, 8),
Adults = 2,
Kids = 1,
ReservationStatusId = null,
PaymentTypeId = null,
TotalAmount = 1000,
PricePerDay = 250,
TotalDays = 4,
AdvancedPayment = 300,
ReservationRooms = new List <ReservationRoom> {
new ReservationRoom {
RoomId = context.Rooms.First().Id
}
},
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await reservationsService.AddReservationAsync(reservation);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
MapperInitializer.MapperConfiguration();
//services.AddDbContext<QuartzDataContext>(ServiceLifetime.Singleton);
services.AddDbContext <QuartzDataContext>(options =>
{
options.UseSqlServer("Server=10.0.130.5;Database=DB_Scheduler;User Id=pirischeduler;Password=pirischeduler5*", opt =>
{
opt.EnableRetryOnFailure();
opt.CommandTimeout(3000);
});
},
ServiceLifetime.Singleton);
services.AddSingleton <IHttpHelper, HttpHelper>();
services.AddTransient <IJobService, JobService>();
services.AddTransient <IScheduleJob, QuartzService>();
services.AddLogging();
services.UseQuartz(typeof(SimpleTestProcess));
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1.0", new Info {
Title = "Scheduler API", Version = "1.0",
Description = @"REST services for managing your API ecosystem.
## Quartz ##
Manages your scheduled jobs via API.Adds new job , pausing all , resuming all etc."
, Contact = new Contact()
{
Name = "Piri Medya", Url = "http://pirimedya.com/", Email = "*****@*****.**"
}
});
c.CustomSchemaIds(x => x.FullName);
c.IncludeXmlComments($"{_environment.WebRootPath}\\Piri.Framework.Scheduler.Quartz.xml", true);
c.UseReferencedDefinitionsForEnums();
});
Console.WriteLine("deneme");
}
public async Task GetViewModelByIdAsync_WithExistentId_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "RoomTypesService GetViewModelByIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomTypesServiceTestsSeeder();
await seeder.SeedRoomTypesAsync(context);
var roomTypeRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomTypesService = this.GetRoomTypesService(roomTypeRepository, context);
var roomTypeId = roomTypeRepository.All().First().Id;
// Act
var actualResult = await roomTypesService.GetViewModelByIdAsync <EditRoomTypeViewModel>(roomTypeId);
var expectedResult = new EditRoomTypeViewModel
{
Id = roomTypeId,
Name = roomTypeRepository.All().First().Name,
CapacityAdults = roomTypeRepository.All().First().CapacityAdults,
CapacityKids = roomTypeRepository.All().First().CapacityKids,
Image = roomTypeRepository.All().First().Image,
Description = roomTypeRepository.All().First().Description,
Price = roomTypeRepository.All().First().Price,
};
// Assert
Assert.True(expectedResult.Id == actualResult.Id, errorMessagePrefix + " " + "Id is not returned properly.");
Assert.True(expectedResult.Name == actualResult.Name, errorMessagePrefix + " " + "Name is not returned properly.");
Assert.True(expectedResult.Price == actualResult.Price, errorMessagePrefix + " " + "Price is not returned properly.");
Assert.True(expectedResult.CapacityAdults == actualResult.CapacityAdults, errorMessagePrefix + " " + "Capacity Adults is not returned properly.");
Assert.True(expectedResult.CapacityKids == actualResult.CapacityKids, errorMessagePrefix + " " + "Capacity Kids is not returned properly.");
Assert.True(expectedResult.Image == actualResult.Image, errorMessagePrefix + " " + "Image is not returned properly.");
Assert.True(expectedResult.Description == actualResult.Description, errorMessagePrefix + " " + "Description is not returned properly.");
}
public async Task AddRequestForRecipientCorrectlyTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var recipientHospitalDataRepository = new EfDeletableEntityRepository <RecipientHospitalData>(dbContext);
var service = new RecipientsService(
recipientRepository,
hospitalDataRepository,
recipientReques,
recipientHospitalDataRepository);
await service.AddRequestForRecipient("123", "456");
var result = recipientReques.All().Count();
Assert.Equal(1, result);
}
public async Task DeleteAsyncRecipientsThrowsExceptionTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var recipientHospitalDataRepository = new EfDeletableEntityRepository <RecipientHospitalData>(dbContext);
var service = new RecipientsService(
recipientRepository,
hospitalDataRepository,
recipientReques,
recipientHospitalDataRepository);
await SeedDataAsync(dbContext);
var hospital = hospitalDataRepository.All().FirstOrDefault();
await Assert.ThrowsAsync <ArgumentException>(() => service.DeleteAsync(hospital.ApplicationUserId, "1"));
}
public async Task AllHospitalRecipientsShouldReturnNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var recipientHospitalDataRepository = new EfDeletableEntityRepository <RecipientHospitalData>(dbContext);
var service = new RecipientsService(
recipientRepository,
hospitalDataRepository,
recipientReques,
recipientHospitalDataRepository);
await SeedDataAsync(dbContext);
var result = service.AllHospitalRecipients <RecipientInfoViewModel>(null).Count();
Assert.Equal(0, result);
}
public async Task TestGetExercisesByKeyWordAsync_WithValidData_ShouldReturnCorrectExercises(string keyWord)
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var repository = new EfDeletableEntityRepository <Exercise>(context);
await repository.AddAsync(new Exercise { Name = "first", MuscleGroup = MuscleGroup.Abs });
await repository.AddAsync(new Exercise { Name = "second", MuscleGroup = MuscleGroup.Abs });
await repository.AddAsync(new Exercise { Name = "third", MuscleGroup = MuscleGroup.Shoulders });
await repository.AddAsync(new Exercise { Name = "fourth", MuscleGroup = MuscleGroup.Upper_Legs });
await repository.SaveChangesAsync();
var service = new ExercisesService(repository);
var exercises = await service.GetExercisesByKeyWordAsync(keyWord);
Assert.Equal("first", exercises[0].Name);
Assert.Single(exercises);
}
public async Task AddPaymentTypeAsync_WithCorrectData_ShouldSuccessfullyCreate()
{
var errorMessagePrefix = "PaymentTypesService AddPaymentTypeAsync() method does not work properly.";
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
var paymentTypesService = this.GetPaymentTypesService(paymentTypeRepository);
var paymentTypeModel = new PaymentType
{
Name = "Test",
};
// Act
await paymentTypesService.AddPaymentTypeAsync(paymentTypeModel);
var actualResult = paymentTypeRepository.All().First();
var expectedResult = paymentTypeModel;
// Assert
Assert.True(expectedResult.Name == actualResult.Name, errorMessagePrefix + " " + "Name is not returned properly.");
}
public async Task CreateAllAsync_ShouldReturnCorrectResult()
{
var errorMessage = "ReservationStatusesService CreateAllAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context);
var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context);
var seeder = new ReservationStatusesServiceTestsSeeder();
await seeder.SeedReservationStatusAsync(context);
// Act
await reservationStatusesService.CreateAllAsync(new string[] { "Test-1" });
var actualResult = new ReservationStatus {
Name = "Test-1"
};
var expectedResult = reservationStatusRepository.All().First();
// Assert
Assert.True(expectedResult.Name == actualResult.Name, errorMessage + " " + "Name is not returned properly.");
}
private MessagesService IntializeMessagesService(SteuDbContext context)
{
var repository = new EfDeletableEntityRepository <Message>(context);
var mapper = new Mock <IMapper>();
var ordersService = new Mock <IOrdersService>();
ordersService.Setup(x => x.GetOrderByIdAsync <SendMessageInputModel>("orderId"))
.Returns(Task.FromResult(new SendMessageInputModel()
{
CountryFrom = "Bulgaria"
}));
var replaysService = new Mock <IReplaysService>();
MapperInitializer.InitializeMapper();
var service = new MessagesService(
repository,
mapper.Object,
ordersService.Object,
replaysService.Object);
return(service);
}
public async Task AddReservationStatusAsync_WithCorrectData_ShouldSuccessfullyCreate()
{
var errorMessagePrefix = "ReservationService AddReservationStatusAsync() method does not work properly.";
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context);
var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context);
var reservationStatusModel = new ReservationStatus
{
Name = "Test",
};
// Act
await reservationStatusesService.AddReservationStatusAsync(reservationStatusModel);
var actualResult = reservationStatusRepository.All().First();
var expectedResult = reservationStatusModel;
// Assert
Assert.True(expectedResult.Name == actualResult.Name, errorMessagePrefix + " " + "Name is not returned properly.");
}
public async Task EditAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedReviewAsync(context);
var reviewRepository = new EfDeletableEntityRepository <Review>(context);
var reviewService = this.GetReviewService(reviewRepository);
var reviewServiceModel = reviewRepository.All().First().To <ReviewServiceModel>();
reviewServiceModel.Rating = 0;
reviewServiceModel.Comment = "New Comment";
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await reviewService.EditAsync(reviewServiceModel.Id, reviewServiceModel);
});
}
public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "ReviewService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedReviewAsync(context);
var reviewRepository = new EfDeletableEntityRepository <Review>(context);
var reviewService = this.GetReviewService(reviewRepository);
var reviewServiceModel = reviewRepository.All().First().To <ReviewServiceModel>();
reviewServiceModel.Rating = 1;
reviewServiceModel.Comment = "New Comment";
// Act
var result = await reviewService.EditAsync(reviewServiceModel.Id, reviewServiceModel);
// Assert
Assert.True(result, errorMessagePrefix + " " + "Returns false.");
}
public async Task GetAllReservationStatuses_ShouldReturnCorrectCount()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context);
var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context);
var seeder = new ReservationStatusesServiceTestsSeeder();
await seeder.SeedReservationStatusAsync(context);
// Act
var actualResult = reservationStatusesService.GetAllReservationStatuses <DetailsReservationStatusViewModel>().ToList();
var expectedResult = new DetailsReservationStatusViewModel[]
{
new DetailsReservationStatusViewModel
{
Id = reservationStatusRepository.All().First().Id,
Name = reservationStatusRepository.All().First().Name,
},
};
Assert.Equal(expectedResult.Length, actualResult.Count());
}
public async Task GetAllPaymentTypesAsyn_ShouldReturnCorrectCount()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var paymentTypeRepository = new EfDeletableEntityRepository <PaymentType>(context);
var paymentTypesService = this.GetPaymentTypesService(paymentTypeRepository);
var seeder = new PaymentTypesServiceTestsSeeder();
await seeder.SeedPaymentTypeAsync(context);
// Act
var actualResult = paymentTypesService.GetAllPaymentTypes <DetailsPaymentTypeViewModel>().ToList();
var expectedResult = new DetailsPaymentTypeViewModel[]
{
new DetailsPaymentTypeViewModel
{
Id = paymentTypeRepository.All().First().Id,
Name = paymentTypeRepository.All().First().Name,
},
};
Assert.Equal(expectedResult.Length, actualResult.Count());
}
public async Task AddReservationStatusAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationStatusRepository = new EfDeletableEntityRepository <ReservationStatus>(context);
var reservationStatusesService = this.GetReservationStatusesService(reservationStatusRepository, context);
var seeder = new ReservationStatusesServiceTestsSeeder();
await seeder.SeedReservationStatusAsync(context);
var reservationStatusModel = new ReservationStatus
{
Name = null,
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await reservationStatusesService.AddReservationStatusAsync(reservationStatusModel);
});
}
public async Task GetAllTypesAsync_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "LifestyleService GetAllTypesAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
await this.SeedDataAsync(context);
var lifestyleRepository = new EfRepository <Lifestyle>(context);
var lifestyleService = new LifestyleService(lifestyleRepository);
// Act
var actualResult = (await lifestyleService.GetAllTypesAsync()).ToList();
var expectedResult = this.GetDummyData().Select(x => x.Type).ToList();
// Assert
for (int i = 0; i < actualResult.Count; i++)
{
Assert.True(expectedResult[i] == actualResult[i], errorMessagePrefix + " " + "Expected type and actual type do not match.");
}
}
public async Task GetRecipeIdsByLifestyleIdAsync_WithNonExistentLifestyleId_ShouldReturnEmptyCollection()
{
var errorMessagePrefix = "RecipeLifestyleService GetRecipeIdsByLifestyleIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var recipeLifestyleRepository = new EfRepository <RecipeLifestyle>(context);
var recipeLifestyleService = new RecipeLifestyleService(recipeLifestyleRepository);
await this.SeedDataAsync(context);
var nonExistentLifestyleId = 10000;
// Act
var actualResult = (await recipeLifestyleService
.GetRecipeIdsByLifestyleIdAsync(nonExistentLifestyleId))
.Count;
var expectedResult = 0;
// Assert
Assert.True(expectedResult == actualResult, errorMessagePrefix + " " + "Collections is not empty.");
}
public async Task AddAsync_WithCorrectData_ShouldSuccessfullyCreate()
{
var errorMessage = "PaymentsService AddPaymentAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new PaymentsServiceTestsSeeder();
await seeder.SeedPaymentAsync(context);
var paymentRepository = new EfDeletableEntityRepository <Payment>(context);
var paymentsService = this.GetPaymentsService(paymentRepository);
var paymentModel = new Payment
{
DateOfPayment = DateTime.Now.Date,
Amount = 300,
PaymentTypeId = context.PaymentTypes.First().Id,
ReservationPayments = new List <ReservationPayment>
{
new ReservationPayment {
ReservationId = context.Reservations.First().Id
}
},
};
// Act
await paymentsService.AddPaymentAsync(paymentModel);
var actualResult = paymentRepository.All().First();
var expectedResult = paymentModel;
// Assert
Assert.True(expectedResult.DateOfPayment == actualResult.DateOfPayment, errorMessage + " " + "Date of payment is not returned properly.");
Assert.True(expectedResult.Amount == actualResult.Amount, errorMessage + " " + "Amount is not returned properly.");
Assert.True(expectedResult.PaymentTypeId == actualResult.PaymentTypeId, errorMessage + " " + "payment type id is not returned properly.");
}
public async Task CreateHospitalUserIsInCorrectRoleTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var rolesRepository = new EfDeletableEntityRepository <ApplicationRole>(dbContext);
var appUsersHospitalRepository = new EfDeletableEntityRepository <ApplicationUserHospitalData>(dbContext);
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var bloodBankRepository = new EfDeletableEntityRepository <BloodBank>(dbContext);
var hospitalBloodBankRepository = new EfDeletableEntityRepository <HospitalDataBloodBank>(dbContext);
var bagRepository = new EfDeletableEntityRepository <BloodBag>(dbContext);
var userManager = this.GetUserManagerMock();
var service = new HospitalsService(
usersRepository,
hospitalDataRepository,
rolesRepository,
appUsersHospitalRepository,
recipientRepository,
bloodBankRepository,
hospitalBloodBankRepository,
bagRepository);
await SeedDataAsync(dbContext);
await service.CreateHospitalProfileAsync(this.SeedInputs(), this.SeedInputs().Id);
var user = usersRepository.All().Where(u => u.UserName == "User1").FirstOrDefault();
var isInRole = await userManager.Object.IsInRoleAsync(user, GlobalConstants.HospitaltRoleName);
Assert.True(isInRole);
}
public async Task GetHospitalByUserIdShouldReturnNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var rolesRepository = new EfDeletableEntityRepository <ApplicationRole>(dbContext);
var appUsersHospitalRepository = new EfDeletableEntityRepository <ApplicationUserHospitalData>(dbContext);
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var bloodBankRepository = new EfDeletableEntityRepository <BloodBank>(dbContext);
var hospitalBloodBankRepository = new EfDeletableEntityRepository <HospitalDataBloodBank>(dbContext);
var bagRepository = new EfDeletableEntityRepository <BloodBag>(dbContext);
var userManager = this.GetUserManagerMock();
var service = new HospitalsService(
usersRepository,
hospitalDataRepository,
rolesRepository,
appUsersHospitalRepository,
recipientRepository,
bloodBankRepository,
hospitalBloodBankRepository,
bagRepository);
await SeedDataAsync(dbContext);
var user = usersRepository.All().FirstOrDefault();
await service.CreateHospitalProfileAsync(this.SeedInputs(), user.Id);
var result = service.GetHospitalDataById <HospitalProfileInputModel>("111", "111");
Assert.Null(result);
}
public async Task CreateCompanyAsyncTest_WithNullUIC_ShouldReturnArgumentNullException()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
MapperInitializer.InitializeMapper();
var repository = new EfDeletableEntityRepository <Company>(context);
var service = new CompaniesService(repository);
var model = new CreateCompanyBindingModel()
{
Name = "tralala",
UIC = null,
UserId = "asdasd asd asd asd ",
LicenseUrl = "dadadasdadasd",
};
var user = new SteuUser()
{
Id = "asdadas",
};
await Assert.ThrowsAsync <ArgumentNullException>(() => service.CreateCompanyAsync(model, user));
}
public async Task GetShoppingListsByUserIdAsync_WithNonExistentUserId_ShouldReturnEmptyCollection()
{
var errorMessagePrefix = "UserShoppingListService GetShoppingListsByUserIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var userShoppingListRepository = new EfRepository <UserShoppingList>(context);
var userShoppingListService = new UserShoppingListService(userShoppingListRepository);
await this.SeedDataAsync(context);
var nonExistentUserId = Guid.NewGuid().ToString();
// Act
var actualResult = (await userShoppingListService
.GetShoppingListsByUserIdAsync(nonExistentUserId))
.ToList()
.Count;
var expectedResult = 0;
// Assert
Assert.True(expectedResult == actualResult, errorMessagePrefix + " " + "Collection is not empty.");
}
