public async Task TestConsultation_AddPatient_ConsultationHasValidSchema()
{
using (NodeRunner.Start())
{
var consultation = await AddPatientGetConsultation("Lynn Hill", Condition.flu);
var errorString = await ValidateResponse <Consultation>("consultations", consultation.id);
Assert.True(errorString == null, errorString);
}
}
public async Task TestDoctor_HasUniqueId()
{
using (NodeRunner.Start())
{
var doctors = await GetRequest <List <Doctor> >("doctors");
var numDoctors = doctors.Count;
var numIds = doctors.Select(d => d.id).Distinct().Count();
Assert.Equal(numDoctors, numIds);
}
}
public async Task TestDoctor_HasValidSchema()
{
using (NodeRunner.Start())
{
var doctors = await GetRequest <List <Doctor> >("doctors");
var errorString = await ValidateResponse <Doctor>("doctors", doctors.First().id);
Assert.True(errorString == null, errorString);
}
}
public async Task TestConsultation_AddTwoPatients_FirstConsultationStaysSame()
{
using (NodeRunner.Start())
{
var initialConsultation = await AddPatientGetConsultation("First patient", Condition.flu);
await AddPatient("Second patient", Condition.flu);
var allConsultations = await GetConsultations();
Assert.Equal(initialConsultation, allConsultations.Where(c => c.id == initialConsultation.id).Single());
}
}
public async Task TestConsultation_AddBreastPatient_GetsRoomWithTreatmentMachine()
{
using (NodeRunner.Start())
{
var consultation = await AddPatientGetConsultation("Dag", Condition.breastcancer);
var rooms = await GetRequest <List <Room> >("rooms");
var room = rooms.Where(r => r.id == consultation.roomId).Single();
Assert.NotNull(room.treatmentMachineId);
}
}
public async Task TestConsultation_AddFluPatient_SchedulesWithGeneralPractitioner()
{
using (NodeRunner.Start())
{
var consultation = await AddPatientGetConsultation("Dag", Condition.flu);
var doctors = await GetRequest <List <Doctor> >("doctors");
var doctor = doctors.Where(d => d.id == consultation.doctorId).Single();
Assert.True(doctor.roles.Any(r => r == Role.GeneralPractitioner), "Flu patient is scheduled with general practitioner");
}
}
public async Task TestImage_Add_SucceedsAndReturnsId()
{
using (NodeRunner.Start())
{
var id = await AddImage();
var image = await GetRequest <Image>("images", id);
Assert.Equal(id, image.id);
Assert.NotEmpty(id);
}
}
public async Task TestConsultation_AddHeadAndNeckPatient_SchedulesWithOncologist()
{
using (NodeRunner.Start())
{
var consultation = await AddPatientGetConsultation("Dag", Condition.headandneckcancer);
var doctors = await GetRequest <List <Doctor> >("doctors");
var doctor = doctors.Where(d => d.id == consultation.doctorId).Single();
Assert.True(doctor.roles.Any(r => r == Role.Oncologist), "Head and neck cancer patient is scheduled with oncologist");
}
}
public async Task TestRoom_HasValidMachine()
{
using (NodeRunner.Start())
{
var rooms = await GetRequest <List <Room> >("rooms");
var machinesInRooms = rooms.Where(r => r.treatmentMachineId != null).Select(r => r.treatmentMachineId);
var machines = await GetRequest <List <Machine> >("machines");
var machineIds = machines.Select(m => m.id);
var notValidIds = machineIds.Except(machineIds);
Assert.Equal(0, notValidIds.Count());
}
}
public async Task TestMachine_HasValidSchema()
{
using (NodeRunner.Start())
{
var machines = await GetRequest <List <Machine> >("machines");
foreach (var machine in machines)
{
var errorString = await ValidateResponse <Machine>("machines", machine.id);
Assert.True(errorString == null, errorString);
}
}
}
public async Task TestConsultation_AddHeadAndNeckPatient_GetsRoomWithAdvancedTreatmentMachine()
{
using (NodeRunner.Start())
{
var consultation = await AddPatientGetConsultation("Dag", Condition.breastcancer);
var rooms = await GetRequest <List <Room> >("rooms");
var room = rooms.Where(r => r.id == consultation.roomId).Single();
Assert.NotNull(room.treatmentMachineId);
var machines = await GetRequest <List <Machine> >("machines");
var machine = machines.Where(m => m.id == room.treatmentMachineId).Single();
Assert.True(machine.capability == Capability.advanced, "Head and neck patient gets advanced machine");
}
}
public static NodeRunner Start()
{
var jsFile = ConfigurationManager.AppSettings["jsFile"];
if (!File.Exists(jsFile))
{
string exceptionMessage = "Specify path to the app.js in RayCareTestTask.dll.config file. The property is named jsFile\n" +
"E.g. <add key=\"jsFile\" value=" +
@"""C: \Users\dalovenv\Documents\github\raysearch\server\node_modules\frontend_test\build\app.js""/>";
throw new FileNotFoundException(exceptionMessage);
}
var instance = new NodeRunner(jsFile);
instance.StartNode();
return(instance);
}
public async Task TestDoctor_AddPatient_AllDoctorsHasValidSchema()
{
using (NodeRunner.Start())
{
await AddPatient("John Gill", Condition.headandneckcancer);
var doctors = await GetRequest <List <Doctor> >("doctors");
foreach (var doctor in doctors)
{
var errorString = await ValidateResponse <Doctor>("doctors", doctor.id);
Assert.True(errorString == null, errorString);
}
}
}
public async Task TestConsultation_AddPatient_ConsultationIsCreatedForNextDay()
{
using (NodeRunner.Start())
{
var patient = await AddPatient("John Sherman", Condition.headandneckcancer);
var consultations = await GetConsultations();
var consultation = consultations.Where(c => c.patientId == patient.id).Single();
Assert.NotEmpty(consultation.id);
Assert.Equal(DateTime.Now.Date, consultation.registrationDate.Date);
Assert.Equal(patient.id, consultation.patientId);
Assert.Equal(DateTime.Now.AddDays(1).Date, consultation.consultationDate.Date);
}
}
public async Task TestConsultation_AddTwoFluPatientsAndTwoBreastPatients_DontCrash()
{
using (NodeRunner.Start())
{
var config = await GetConfiguration();
foreach (var i in Enumerable.Range(1, config.GeneralPractitioners))
{
await AddPatient("Flu patient " + i, Condition.flu);
}
foreach (var i in Enumerable.Range(1, config.AdvancedMachines))
{
await AddPatient("Head and neck patient " + i, Condition.breastcancer);
}
Assert.True(true);
}
}
public async Task TestPatient_AddPatient_SucceedsAndReturnsId()
{
using (NodeRunner.Start())
{
var patient = new Patient
{
name = "Dag",
condition = Condition.flu,
imageId = await AddImage()
};
var response = await PostRequest("patients", patient);
var readPatient = await GetRequest <Patient>("patients", response.id);
Assert.Equal(response.id, readPatient.id);
Assert.NotEmpty(response.id);
}
}
public async Task TestDoctor_HasValidImage()
{
using (NodeRunner.Start())
{
var doctors = await GetRequest <List <Doctor> >("doctors");
var images = await GetRequest <List <Image> >("images");
var uris = doctors.Join(images, d => d.imageId, i => i.id, (d, i) => new Uri(i.url));
using (var httpClient = new HttpClient())
{
foreach (var uri in uris)
{
var response = await httpClient.GetAsync(uri);
Assert.True(response.IsSuccessStatusCode, string.Format("{0} is a valid URI", uri));
}
}
}
}
public async Task TestConsultation_BookRooms_NoDoubleBookingsAndCorrectDays()
{
using (NodeRunner.Start())
{
var config = await GetConfiguration();
var consultationsPerDay = Math.Min(config.AdvancedMachines, config.Oncologists);
var numConsultations = consultationsPerDay * 2;
var expectDates = new List <DateTime>();
foreach (var i in Enumerable.Range(0, numConsultations))
{
await AddPatient("Patient " + i, Condition.headandneckcancer);
expectDates.Add(DateTime.Now.AddDays(1 + i / consultationsPerDay).Date);
}
var consultations = await GetConsultations();
var numUnique = consultations.Select(c => new { c.consultationDate.Date, c.roomId }).Distinct().Count();
Assert.Equal(numConsultations, numUnique);
Assert.Equal(expectDates, consultations.Select(c => c.consultationDate.Date).OrderBy(d => d));
}
}
public async Task TestPatient_Add_AllPropertiesStored()
{
using (NodeRunner.Start())
{
var imageId = await AddImage();
var patient = new Patient
{
name = "Dag",
condition = Condition.flu,
imageId = imageId
};
var response = await PostRequest("patients", patient);
var storedPatient = await GetRequest <Patient>("patients", response.id);
Assert.Equal(response.id, storedPatient.id);
Assert.Equal("Dag", storedPatient.name);
Assert.Equal(imageId, storedPatient.imageId);
Assert.Equal(Condition.flu, storedPatient.condition);
}
}
