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;
}
