public async Task FindByIdShouldReturnCorrectResultDisease()
{
var db = Tests.GetDatabase();
var firstDisease = new Disease {
Id = 1, Name = "First"
};
var secondDisease = new Disease {
Id = 2, Name = "Second"
};
var thirdDisease = new Disease {
Id = 3, Name = "Third"
};
var fourthDisease = new Disease {
Id = 4, Name = "Fourth"
};
db.AddRange(firstDisease, secondDisease, thirdDisease, fourthDisease);
await db.SaveChangesAsync();
var diseaseService = new DiseaseService(db);
var result = await diseaseService.FindById(1);
result.Should()
.NotBeNull();
result.Should()
.BeOfType <Disease>();
}
public async Task AllShouldReturnCorrectResultWithCorrectOrder()
{
var db = Tests.GetDatabase();
var department = new Department {
Id = 1, Name = "Gosho"
};
var firstDisease = new Disease {
Id = 1, Name = "First", Department = department
};
var secondDisease = new Disease {
Id = 2, Name = "Second", Department = department
};
var thirdDisease = new Disease {
Id = 3, Name = "Third", Department = department
};
var fourthDisease = new Disease {
Id = 4, Name = "Fourth", Department = department
};
db.AddRange(firstDisease, secondDisease, thirdDisease, fourthDisease);
await db.SaveChangesAsync();
var diseaseService = new DiseaseService(db);
var result = await diseaseService.All();
result.Should()
.HaveCount(4);
}
public async Task EditShouldReturnTrueAndEditedDisease()
{
var db = Tests.GetDatabase();
var diseaseService = new DiseaseService(db);
var department = new Department {
Id = 1, Name = "Gosho"
};
await diseaseService.Create("Name", "Description", department);
await db.SaveChangesAsync();
var id = await db.Diseases
.Where(d => d.Name == "Name")
.Select(d => d.Id)
.FirstOrDefaultAsync();
var edited = await diseaseService
.Edit(id, "EditedName", "Description", department.Name);
edited.Should()
.BeTrue();
db.Diseases.Should()
.HaveCount(1);
}
public async Task SearchShouldReturnCorrectResultWithCorrectOrder()
{
var db = Tests.GetDatabase();
var department = new Department {
Id = 1, Name = "Gosho"
};
var firstDisease = new Disease {
Id = 1, Name = "First", Department = department
};
var secondDisease = new Disease {
Id = 2, Name = "Second", Department = department
};
var thirdDisease = new Disease {
Id = 3, Name = "Third", Department = department
};
var fourthDisease = new Disease {
Id = 4, Name = "Fourth", Department = department
};
db.AddRange(firstDisease, secondDisease, thirdDisease, fourthDisease);
await db.SaveChangesAsync();
var diseaseService = new DiseaseService(db);
var result = await diseaseService.Search("f");
result.Should()
.Match(r => r.ElementAt(0).Id == 1 &&
r.ElementAt(1).Id == 4)
.And
.HaveCount(2);
}
public async Task DiseaseExistsShouldReturnCorrectResultTrue()
{
var db = Tests.GetDatabase();
var firstDisease = new Disease {
Name = "First"
};
var secondDisease = new Disease {
Name = "Second"
};
var thirdDisease = new Disease {
Name = "Third"
};
var fourthDisease = new Disease {
Name = "Fourth"
};
db.AddRange(firstDisease, secondDisease, thirdDisease, fourthDisease);
await db.SaveChangesAsync();
var diseaseService = new DiseaseService(db);
var result = await diseaseService.DiseaseExists(1);
result.Should()
.Be(true);
}
IDiseaseService GetDiseaseService()
{
var mockContext = new Mock <IUnitOfWork>();
var expectedDisease = new Disease()
{
ID = 1, Name = "testName"
};
var mockDbSet = new Mock <IDiseaseRepository>();
mockDbSet.Setup(z =>
z.Find(
It.IsAny <Func <Disease, bool> >(),
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(
new List <Disease>()
{
expectedDisease
}
);
mockContext
.Setup(context =>
context.Diseases)
.Returns(mockDbSet.Object);
IDiseaseService diseaseService = new DiseaseService(mockContext.Object);
return(diseaseService);
}
public void GetDiseaseById_ValidIdTest(int diseaseId)
{
// Arrange
_mockData.Setup(q => q.Diseases.Get(diseaseId)).Returns(_diseasesList[diseaseId - 1]);
// Act
var actual = new DiseaseService(_mockData.Object).GetDiseaseById(diseaseId);
// Assert
Assert.AreEqual(_diseasesList[diseaseId - 1], actual);
}
public void GetDiseaseById_InValidIdTest(int diseaseId)
{
// Arrange
_mockData.Setup(q => q.Diseases.Get(diseaseId)).Returns(default(Disease));
// Act
var actual = new DiseaseService(_mockData.Object).GetDiseaseById(diseaseId);
// Assert
Assert.AreEqual(null, actual);
}
private static DiseaseFacade CreateDiseaseFacade(Mock <QueryObjectBase <DiseaseDto, Disease, DiseaseFilterDto, IQuery <Disease> > > diseaseQueryMock, Mock <IRepository <Disease> > diseaseRepository,
Mock <QueryObjectBase <SympthomDto, Sympthom, SympthomFilterDto, IQuery <Sympthom> > > sympthomQueryMock, Mock <IRepository <Sympthom> > sympthomRepository)
{
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapperMock = FacadeMockManager.ConfigureRealMapper();
var diseaseService = new DiseaseService(mapperMock, diseaseRepository.Object, diseaseQueryMock.Object);
var healthCardService = new SympthomService(mapperMock, sympthomRepository.Object, sympthomQueryMock.Object);
var diseaseFacade = new DiseaseFacade(uowMock.Object, diseaseService, healthCardService);
return(diseaseFacade);
}
public async Task CreateShouldReturnTrueAndNewDisease()
{
var db = Tests.GetDatabase();
var diseaseService = new DiseaseService(db);
var department = new Department {
Id = 1, Name = "Gosho"
};
await diseaseService.Create("Name", "Description", department);
db.Diseases.Should()
.HaveCount(1);
}
public void GetDiseases_UserIsAnalyst_ThrowMethodAccessException()
{
// Arrange
User user = new Analyst("test", 1);
SecurityContext.SetUser(user);
var mockUnitOfWork = new Mock <IUnitOfWork>();
IDiseaseService diseaseService = new DiseaseService(mockUnitOfWork.Object);
// Act
// Assert
Assert.Throws <MethodAccessException>(() => diseaseService.GetDiseases(0));
}
public void GetAllDiseasesTest()
{
// Arrange
_mockData.Setup(q => q.Diseases.GetAll()).Returns(_diseasesList.AsQueryable);
// Act
var actual = new DiseaseService(_mockData.Object).GetAllDiseases().ToList();
// Assert
Assert.AreEqual(_diseasesList.Count, actual.Count);
Assert.AreEqual(_diseasesList[0].Name, actual[0].Name);
Assert.AreEqual(_diseasesList[1].Name, actual[1].Name);
Assert.AreEqual(_diseasesList[2].Name, actual[2].Name);
}
public void GetDiseasesByCategoryTest(int categoryId)
{
// Arrange
_mockData.Setup(q => q.Diseases.GetAll()).Returns(_diseasesList.AsQueryable);
_mockData.Setup(q => q.Categories.GetAll()).Returns(_categoriesList.AsQueryable);
// Act
var actual = new DiseaseService(_mockData.Object).GetDiseasedByCategory(categoryId).ToList();
// Assert
Assert.AreEqual(2, actual.Count());
Assert.AreEqual(_diseasesList[0].Name, actual[0].Name);
Assert.AreEqual(_diseasesList[1].Name, actual[1].Name);
}
private HospitalManager()
{
logger.Debug("Начинается инициализация управляющего блока.");
if (SerializationService is null)
{
SerializationService = new JsonSerializationService();
}
EmployeeService = new EmployeeService(new EmployeeRepository(SerializationService));
DiagnosisService = new DiagnosisService(new DiagnosisRepository(SerializationService));
TreatmentService = new TreatmentService(new TreatmentRepository(SerializationService));
DiseaseService = new DiseaseService(new DiseaseRepository(SerializationService));
PatientService = new PatientService(new PatientRepository(SerializationService));
VisitService = new VisitService(new VisitRepository(SerializationService));
logger.Debug("Инициализация управляющего блока выполнена.");
}
public void AddDiseaseAsync_ValidDisease_Test()
{
// Arrange
_mockData.Setup(q => q.Diseases.GetAll()).Returns(_diseasesList.AsQueryable);
Disease testDisease = new Disease()
{
Id = 4, CategoryId = 2, Name = "Test Disease Name 4", Description = "Test Disease Name 4 Description Text", IsDeleted = false
};
_mockData.Setup(q => q.Diseases.Insert(testDisease)).Returns(testDisease);
// Act
var actual = new DiseaseService(_mockData.Object).AddDiseaseAsync(testDisease).Result;
// Assert
Assert.AreEqual(testDisease, actual);
_mockData.Verify(d => d.Save(), Times.Once);
}
public async Task CreateAsync_DiseaseValidationSucceed_CreatesStreet()
{
// Arrange
var disease = new DiseaseUpdateModel();
var expected = new Disease();
var diseaseDAL = new Mock <IDiseaseDAL>();
diseaseDAL.Setup(x => x.InsertAsync(disease)).ReturnsAsync(expected);
var diseaseService = new DiseaseService(diseaseDAL.Object);
// Act
var result = await diseaseService.CreateAsync(disease);
// Assert
result.Should().Be(expected);
}
public async Task ValidateAsync_DiseaseExists_DoesNothing()
{
// Arrange
var diseaseContainer = new Mock <IDiseaseContainer>();
var disease = new Disease();
var diseaseDAL = new Mock <IDiseaseDAL>();
var diseaseIdentity = new Mock <IDiseaseIdentity>();
diseaseDAL.Setup(x => x.GetAsync(diseaseIdentity.Object)).ReturnsAsync(disease);
var diseaseGetService = new DiseaseService(diseaseDAL.Object);
// Act
var action = new Func <Task>(() => diseaseGetService.ValidateAsync(diseaseContainer.Object));
// Assert
await action.Should().NotThrowAsync <Exception>();
}
public async Task ValidateAsync_DiseaseNotExists_ThrowsError()
{
// Arrange
var fixture = new Fixture();
var id = fixture.Create <int>();
var diseaseContainer = new Mock <IDiseaseContainer>();
diseaseContainer.Setup(x => x.DiseaseId).Returns(id);
var diseaseIdentity = new Mock <IDiseaseIdentity>();
var disease = new Disease();
var diseaseDAL = new Mock <IDiseaseDAL>();
diseaseDAL.Setup(x => x.GetAsync(diseaseIdentity.Object)).ReturnsAsync((Disease)null);
var diseaseGetService = new DiseaseService(diseaseDAL.Object);
// Act
var action = new Func <Task>(() => diseaseGetService.ValidateAsync(diseaseContainer.Object));
// Assert
await action.Should().ThrowAsync <InvalidOperationException>($"Disease not found by id {id}");
}
private void LoadServices()
{
// HospitalManagementService
doctorStatisticsService = new DoctorStatisticsService(doctorStatisticRepository);
inventoryStatisticsService = new InventoryStatisticsService(inventoryStatisticRepository);
roomStatisticsService = new RoomStatisticsService(roomStatisticRepository);
hospitalService = new HospitalService(hospitalRepository);
inventoryService = new InventoryService(inventoryRepository, inventoryItemRepository, medicineRepository);
roomService = new RoomService(roomRepository, appointmentRepository);
medicineService = new MedicineService(medicineRepository);
// MedicineService
diagnosisService = new DiagnosisService(diagnosisRepository);
diseaseService = new DiseaseService(diseaseRepository);
medicalRecordService = new MedicalRecordService(medicalRecordRepository);
therapyService = new TherapyService(therapyRepository, medicalRecordService);
// MiscService
articleService = new ArticleService(articleRepository);
doctorFeedbackService = new DoctorFeedbackService(doctorFeedbackRepository);
feedbackService = new FeedbackService(feedbackRepository, questionRepository, userRepository);
locationService = new LocationService(locationRepository);
messageService = new MessageService(messageRepository);
notificationService = new NotificationService(notificationRepository);
appointmentNotificationSender = new AppointmentNotificationSender(notificationService);
appointmentService = new AppointmentService(appointmentRepository, appointmentStrategy, appointmentNotificationSender);
pharmacyApiKeyService = new PharmacyApiKeyService(pharmacyApiKeyRepository);
// UsersService
doctorService = new DoctorService(doctorRepository, userRepository, appointmentService);
managerService = new ManagerService(managerRepository);
patientService = new PatientService(patientRepository, medicalRecordRepository);
secretaryService = new SecretaryService(secretaryRepository);
userService = new UserService(userRepository);
appointmentRecommendationService = new AppointmentRecommendationService(appointmentService, doctorService);
}
public DiseasesController(DiseaseService diseaseService)
{
_diseaseService = diseaseService;
}
public DiseaseController(DiseaseService diseaseService)
{
this.diseaseService = diseaseService;
}
