public async Task AddTimeslotAsync_Database_test1() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var timeslot = new Domain.Models.Timeslot(new DateTime(2020, 12, 20, 8, 0, 0)) { Appointment = new Domain.Models.Appointment(5, "idiot can't find his stethoscope") { PatientId = 7, DoctorId = 4 }, Id = 9, DoctorId = 4 }; await repo.AddTimeslotAsync(timeslot); var timeslotActual = context.Timeslots.Find(9); Assert.Equal(timeslotActual.Id, timeslot.Id); Assert.Equal(timeslotActual.DoctorId, timeslot.DoctorId); Assert.Equal(timeslotActual.AppointmentId, timeslot.Appointment?.Id); Assert.Equal(timeslotActual.Start, timeslot.Start); Assert.Equal(timeslotActual.End, timeslot.End); }
public async Task GetPatientReportsAsync_Database_test1(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patientReport = await repo.GetPatientReportsAsync(id); var patientReportActual = context.PatientReports.Where(x => x.PatientId == id); var vitalsActual = context.Vitals.Where(x => patientReportActual.Select(y => y.VitalsId).Contains(x.Id)); foreach (var report in patientReport) { Assert.Contains(report.Id, patientReportActual.Select(x => x.Id)); if (report.Vitals is not null) { Assert.Contains(report.Vitals.Id, vitalsActual.Select(x => x.Id)); Assert.Contains(report.Vitals.Systolic, vitalsActual.Select(x => x.Systolic)); Assert.Contains(report.Vitals.Diastolic, vitalsActual.Select(x => x.Diastolic)); Assert.Contains(report.Vitals.HeartRate, vitalsActual.Select(x => x.HeartRate)); Assert.Contains(report.Vitals.PainLevel, vitalsActual.Select(x => x.Pain)); } Assert.Contains(report.Info, patientReportActual.Select(x => x.Information)); Assert.Contains(report.Time, patientReportActual.Select(x => x.ReportTime)); Assert.Contains(report.PatientId, patientReportActual.Select(x => x.PatientId)); } }
public async Task AddPrescriptionAsync_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var prescription = new Domain.Models.Prescription("Take every 3 hours", "blarbazin") { Id = 8, PatientId = 1, DoctorId = 1 }; await repo.AddPrescriptionAsync(prescription); var prescriptionActual = context.Prescriptions.Find(8); Assert.Equal(prescription.Id, prescriptionActual.Id); Assert.Equal(prescription.Info, prescriptionActual.Information); Assert.Equal(prescription.DrugName, prescriptionActual.Drug); Assert.Equal(prescription.DoctorId, prescriptionActual.DoctorId); Assert.Equal(prescription.PatientId, prescriptionActual.PatientId); }
public async Task AddPatientAsync_Database_Test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patient = new VirtualClinic.Domain.Models.Patient("Billy Mays", DateTime.Now) { SSN = "293-38-0071", InsuranceProvider = "Umbrella Corp", PrimaryDoctor = repo.GetDoctorByID(1) }; await repo.AddPatientAsync(patient); using var context2 = new ClinicDbContext(options); DataModel.Patient patientActual = context2.Patients .Single(l => l.Name == "Billy Mays"); Assert.Equal(patient.Name, patientActual.Name); Assert.Equal(patient.SSN, patientActual.Ssn); Assert.Equal(patient.InsuranceProvider, patientActual.Insurance); }
public async Task GetPatientReportsByIDAsync_Database_test2(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); await Assert.ThrowsAsync <ArgumentException>(() => repo.GetPatientReportByIDAsync(id)); }
public void ProcessRequest(HttpContext context) { //context.Response.ContentType = "text/plain"; //context.Response.Write("Hello World"); string id = context.Request.QueryString["id"]; ClinicDbContext db = new ClinicDbContext(); var pr = db.Doctors.AsEnumerable().First(p => p.DoctorId == int.Parse(id)); context.Response.BinaryWrite(pr.Picture); }
public void GetDoctorbyID_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var doctor = repo.GetDoctorByID(id); var doctorActual = context.Doctors.Where(x => x.Id == id).Single(); Assert.Equal(doctor.Id, doctorActual.Id); Assert.Equal(doctor.Name, doctorActual.Name); }
public async Task GetPatientbyIDAsync_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patient = await repo.GetPatientByIDAsync(id); var patientsActual = context.Patients.Where(x => x.Id == id).Single(); Assert.Equal(patient.Id, patientsActual.Id); Assert.Equal(patient.Name, patientsActual.Name); Assert.Equal(patient.SSN, patientsActual.Ssn); }
public async Task AddPatientReportAsync_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var report = new Domain.Models.PatientReport(patientId: 7, info: "I have a stomach ache", time: DateTime.Now); await repo.AddPatientReportAsync(report); var reportActual = context.PatientReports.Find(7); Assert.Equal(report.PatientId, reportActual.PatientId); Assert.Equal(report.Info, reportActual.Information); Assert.Equal(report.Time, reportActual.ReportTime); }
public async Task GetPrescriptionAsync_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var prescription = await repo.GetPrescriptionAsync(id); var prescriptionActual = context.Prescriptions.Find(id); Assert.Equal(prescription.Id, prescriptionActual.Id); Assert.Equal(prescription.Info, prescriptionActual.Information); Assert.Equal(prescription.DrugName, prescriptionActual.Drug); Assert.Equal(prescription.DoctorId, prescriptionActual.DoctorId); Assert.Equal(prescription.PatientId, prescriptionActual.PatientId); }
public void GetDoctors_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var doctors = repo.GetDoctors(); var doctorsActual = context.Doctors.ToList(); foreach (var doctor in doctors) { Assert.Contains(doctor.Name, doctorsActual.Select(x => x.Name)); Assert.Contains(doctor.Id, doctorsActual.Select(x => x.Id)); Assert.Contains(doctor.Title, doctorsActual.Select(x => x.Title)); } }
public void GetPatients_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patients = repo.GetPatients(); var patientsActual = context.Patients.ToList(); foreach (var patient in patients) { Assert.Contains(patient.Name, patientsActual.Select(x => x.Name)); Assert.Contains(patient.Id, patientsActual.Select(x => x.Id)); Assert.Contains(patient.SSN, patientsActual.Select(x => x.Ssn)); Assert.Contains(patient.InsuranceProvider, patientsActual.Select(x => x.Insurance)); Assert.Contains(patient.DateOfBirth, patientsActual.Select(x => x.Dob)); } }
public async Task GetDoctorTimeslotsAsync_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var timeslots = await repo.GetDoctorTimeslotsAsync(1); var timeslotsActual = context.Timeslots .Where(x => x.DoctorId == 1).ToList(); foreach (var timeslot in timeslots) { Assert.Contains(timeslot.Id, timeslotsActual.Select(x => x.Id)); Assert.Contains(timeslot.Start, timeslotsActual.Select(x => x.Start)); Assert.Contains(timeslot.End, timeslotsActual.Select(x => x.End)); } }
public async Task AddTimeslotAppointmentAsync_Database_test1() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var appointment = new Domain.Models.Appointment("") { DoctorId = 1, PatientId = 3 }; await repo.AddAppointmentToTimeslotAsync(appointment, 1); var timeslotActual = context.Timeslots.Find(1); Assert.NotNull(timeslotActual.AppointmentId); }
public async Task GetPatientTimeslotsAsync_Database_test() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var timeslots = await repo.GetPatientTimeslotsAsync(1); var timeslotsActual = context.Timeslots .Include(x => x.Appointment) .Where(x => x.Appointment.PatientId == 1).ToList(); foreach (var timeslot in timeslots) { Assert.Contains(timeslot.Id, timeslotsActual.Select(x => x.Id)); Assert.Contains(timeslot.Appointment.Notes, timeslotsActual.Select(x => x.Appointment.Notes)); Assert.NotNull(timeslot.Appointment); } }
public void GetPatientPrescriptions_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var prescriptions = repo.GetPatientPrescriptions(id); var prescriptionsActual = context.Prescriptions.Where(x => x.PatientId == id).ToList(); foreach (var prescription in prescriptions) { Assert.Contains(prescription.Id, prescriptionsActual.Select(x => x.Id)); Assert.Contains(prescription.DoctorId, prescriptionsActual.Select(x => x.DoctorId)); Assert.Contains(prescription.PatientId, prescriptionsActual.Select(x => x.PatientId)); Assert.Contains(prescription.DrugName, prescriptionsActual.Select(x => x.Drug)); Assert.Contains(prescription.Info, prescriptionsActual.Select(x => x.Information)); } }
public async Task GetDoctorPatientsAsync_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patients = await repo.GetDoctorPatientsAsync(id); var patientsActual = context.Patients.Where(x => x.DoctorId == id).ToList(); foreach (var patient in patients) { Assert.Contains(patient.Name, patientsActual.Select(x => x.Name)); Assert.Contains(patient.Id, patientsActual.Select(x => x.Id)); Assert.Contains(patient.SSN, patientsActual.Select(x => x.Ssn)); Assert.Contains(patient.InsuranceProvider, patientsActual.Select(x => x.Insurance)); Assert.Contains(patient.DateOfBirth, patientsActual.Select(x => x.Dob)); Assert.Contains(patient.PrimaryDoctor.Id, patientsActual.Select(x => x.DoctorId)); } }
public async Task AddDoctorAsync_Database_Test() { using var connection = new SqliteConnection("Data Source=:memory:"); connection.Open(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; var doctor = new VirtualClinic.Domain.Models.Doctor(101, "Jerry Smith", "MD"); using (var context = new ClinicDbContext(options)) { context.Database.EnsureCreated(); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); await repo.AddDoctorAsync(doctor); } using var context2 = new ClinicDbContext(options); DataModel.Doctor doctorActual = context2.Doctors .Single(l => l.Name == "Jerry Smith"); Assert.Equal(doctor.Name, doctorActual.Name); Assert.Equal(doctor.Title, doctorActual.Title); }
public async Task GetPatientReportsByIDAsync_Database_test1(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var patientReport = await repo.GetPatientReportByIDAsync(id); var patientReportActual = context.PatientReports.Find(id); var vitalsReport = context.Vitals.Find(patientReportActual.VitalsId); Assert.Equal(patientReport.Id, patientReportActual.Id); Assert.Equal(patientReport.Info, patientReportActual.Information); Assert.Equal(patientReport.Time, patientReportActual.ReportTime); Assert.Equal(patientReport.Vitals?.Id, vitalsReport?.Id); Assert.Equal(patientReport.Vitals?.Systolic, vitalsReport?.Systolic); Assert.Equal(patientReport.Vitals?.Diastolic, vitalsReport?.Diastolic); Assert.Equal(patientReport.Vitals?.HeartRate, vitalsReport?.HeartRate); Assert.Equal(patientReport.Vitals?.PainLevel, vitalsReport?.Pain); }
public void AddTimeslot_Database_test2() { using var connection = Database_init(); var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options; using var context = new ClinicDbContext(options); var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>()); var timeslot = new Domain.Models.Timeslot(new DateTime(2020, 12, 20, 8, 0, 0)) { Id = 9, DoctorId = 4 }; repo.AddTimeslot(timeslot); var timeslotActual = context.Timeslots.Find(9); Assert.Equal(timeslotActual.Id, timeslot.Id); Assert.Equal(timeslotActual.DoctorId, timeslot.DoctorId); Assert.Equal(timeslotActual.Start, timeslot.Start); Assert.Equal(timeslotActual.End, timeslot.End); Assert.Null(timeslotActual.Appointment); }
public ContactController(ILogger <ContactController> logger, ClinicDbContext context) { _context = context; }
public EfClinicDbService(ClinicDbContext context) { _context = context; }
public NewsController(ClinicDbContext context, IFileManager fileManager) { _context = context; _fileManager = fileManager; }
public DoctorService(ClinicDbContext dbContext) { _dbContext = dbContext; }
public DoctorsController(ClinicDbContext context, IDbService dbService) { _dbService = dbService; _dbService.DbContext = context; }
public PatientSaysController(ClinicDbContext context, IFileManager fileManager) { _context = context; _fileManager = fileManager; }
public DoctorOpeningHoursController(ClinicDbContext context) { _context = context; }
public HomeController(ClinicDbContext context) { _context = context; //_logger = logger; }
public SqlServerDoctorDbService(ClinicDbContext dbContext) { _dbContext = dbContext; }
public DoctorsController(ClinicDbContext context) { _context = context; }