public void Delete_WhenTheresNoAssociation()
{
PatientsController controller;
int patientId;
Patient patient;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(doctor, this.db, 1);
// we now have 1 patient
patient = this.db.Patients.FirstOrDefault();
Assert.IsNotNull(patient);
patientId = patient.Id;
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
controller.Delete(patientId);
// this patient must have been deleted
patient = this.db.Patients.FirstOrDefault(p => p.Id == patientId);
Assert.IsNull(patient);
}
public void Edit_3_CannotSaveWithInvalidModelIdAndId()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
// tries to save
var formModel = new MedicalCertificateViewModel()
{
// both EXISTING
ModelId = null,
Id = null,
PatientId = patientId,
Fields = new List <MedicalCertificateFieldViewModel>()
{
new MedicalCertificateFieldViewModel()
{
Name = "field_1"
},
new MedicalCertificateFieldViewModel()
{
Name = "field_2"
}
}
};
var mr = new MockRepository(true);
var controller = mr.CreateController <MedicalCertificatesController>();
var controllerResult = controller.Edit(new[] { formModel });
Assert.IsInstanceOfType(controllerResult, typeof(ViewResult));
Assert.AreEqual(false, controller.ModelState.IsValid);
Assert.AreEqual(1, controller.ModelState.Count);
}
public void Edit_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db, 1);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new DiagnosisViewModel
{
PatientId = patientId,
Cid10Code = "CodeX",
Cid10Name = "XDesease",
Text = "Notes"
};
var mr = new MockRepository(true);
var controller = mr.CreateController <DiagnosisController>();
var referenceTime = DateTime.UtcNow;
controller.UtcNowGetter = () => referenceTime;
controller.Edit(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
var diagnosis = this.db.Diagnoses.First();
Assert.AreEqual(0, (referenceTime.Ticks - diagnosis.CreatedOn.Ticks) / 100000);
Assert.AreEqual(patientId, diagnosis.PatientId);
Assert.AreEqual(formModel.Text, diagnosis.Observations);
Assert.AreEqual(formModel.Cid10Code, diagnosis.Cid10Code);
Assert.AreEqual(formModel.Cid10Name, diagnosis.Cid10Name);
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateEnter(animator, stateInfo, layerIndex);
Firestarter firestarter = EnemyBase as Firestarter;
firestarter.isFirestarterAttacking = true;
}
public void Search_ShouldRespectTheSearchTermWhenItsPresent()
{
PatientsController controller = null;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(doctor, this.db, 200);
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
}
var searchTerm = "an";
var matchingPatientsCount = this.db.Patients.Count(p => p.Person.FullName.Contains(searchTerm));
// making an empty search
var result = controller.Search(new Areas.App.Models.SearchModel()
{
Term = searchTerm,
Page = 1
});
Assert.IsInstanceOfType(result, typeof(ViewResult));
var resultAsView = result as ViewResult;
Assert.IsInstanceOfType(resultAsView.Model, typeof(SearchViewModel <PatientViewModel>));
var model = resultAsView.Model as SearchViewModel <PatientViewModel>;
Assert.AreEqual(matchingPatientsCount, model.Count);
Assert.IsTrue(model.Objects.Count >= Code.Constants.GRID_PAGE_SIZE);
}
public void Edit_4_CannotSaveACertificateWithInvalidFields()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
// obtains a valid certificate model
ModelMedicalCertificateViewModel certificateModelFormModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%FIELD_1%>"
};
var mr = new MockRepository(true);
var certificateModelTarget = mr.CreateController <ModelMedicalCertificatesController>();
var certificateModelResult = certificateModelTarget.Edit(certificateModelFormModel);
var modelId = this.db.ModelMedicalCertificates.First().Id;
// tries to save
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
// both EXISTING
ModelId = modelId,
PatientId = patientId
};
var target = mr.CreateController <MedicalCertificatesController>();
var result = target.Edit(new[] { formModel });
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.AreEqual(false, target.ModelState.IsValid);
Assert.AreEqual(1, target.ModelState.Count);
}
public void Index_UserIsSecretary()
{
PracticeHomeController homeController;
var mr = new MockRepository();
try
{
var milena = Firestarter.CreateSecretary_Milena(this.db, this.db.Practices.First());
mr.SetCurrentUser(milena.Users.Single(), "milena");
mr.SetRouteData("Index", "practicehome", "App", "consultoriodrhouse");
homeController = mr.CreateController <PracticeHomeController>(callOnActionExecuting: false);
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Execute test: owner must have access to this view.
var actionResult = Mvc3TestHelper.RunOnAuthorization(homeController, "Index")
?? Mvc3TestHelper.RunOnActionExecuting(homeController, "Index")
?? homeController.Index();
// Asserts
Assert.IsInstanceOfType(actionResult, typeof(ViewResult));
Assert.AreEqual(null, ((ViewResult)actionResult).View);
}
public void MedicalCertificateFieldsEditor_2_ModelIdIsSuppliedAndCertficateIdIsNot()
{
// create a model
ModelMedicalCertificateViewModel formModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%PROP_1%>, <%pRoP_2%>, <%PrOP_3%>, <%ProP_4%>"
};
var mr = new MockRepository(true);
var certificateModelcontroller = mr.CreateController <ModelMedicalCertificatesController>();
certificateModelcontroller.Edit(formModel);
var modelId = this.db.ModelMedicalCertificates.Select(m => m.Id).First();
// create a certificate
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var controller = mr.CreateController <MedicalCertificatesController>();
var controllerResult = controller.MedicalCertificateFieldsEditor(modelId, null, null);
// obtaining the view-model
ViewResult view = (ViewResult)controllerResult;
var viewModel = (MedicalCertificateViewModel)view.Model;
Assert.AreEqual(4, viewModel.Fields.Count);
}
public void EditPost_UserIsSecretary()
{
PracticeHomeController homeController;
var mr = new MockRepository();
try
{
var milena = Firestarter.CreateSecretary_Milena(this.db, this.db.Practices.First());
mr.SetCurrentUser(milena.Users.Single(), "milena");
mr.SetRouteData("Edit", "practicehome", "App", "consultoriodrhouse");
homeController = mr.CreateController <PracticeHomeController>(callOnActionExecuting: false);
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Execute test: owner must have access to this view.
var actionResult = Mvc3TestHelper.RunOnAuthorization(homeController, "Edit", "POST")
?? Mvc3TestHelper.RunOnActionExecuting(homeController, "Edit", "POST")
?? homeController.Edit(new PracticeHomeControllerViewModel
{
PracticeName = "My New Practice Name",
PracticeTimeZone = 3
});
// Asserts
Assert.IsInstanceOfType(actionResult, typeof(UnauthorizedResult));
}
public void Delete_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db, 1);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new DiagnosisViewModel
{
PatientId = patientId,
Text = "This is my diagnosis",
Cid10Code = "Q878",
Cid10Name = "Doença X"
};
var mr = new MockRepository(true);
var controller = mr.CreateController <DiagnosisController>();
controller.Create(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
// get's the newly created diagnosis
var newlyCreatedDiagnosis = this.db.Diagnoses.First();
// tries to delete the anamnese
var result = controller.Delete(newlyCreatedDiagnosis.Id);
var deleteMessage = (JsonDeleteMessage)result.Data;
Assert.AreEqual(true, deleteMessage.success);
Assert.AreEqual(0, this.db.Anamnese.Count());
}
public void SendEmailToUser_HappyPath()
{
bool isDbChanged = false;
// Dates that will be used by this test.
// - utcNow and localNow: used to mock Now values from Utc and User point of view.
// - start and end: start and end time of the appointments that will be created.
var localNow = new DateTime(2012, 11, 23, 10, 00, 00, 000);
MailMessage mailMessage = null;
EmailSenderWorker worker;
try
{
var docAndre = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
Firestarter.SetupDoctor(docAndre, this.db);
var timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(docAndre.Users.Single().Practice.WindowsTimeZoneId);
DateTime utcNow = TimeZoneInfo.ConvertTimeToUtc(localNow, timeZoneInfo);
// Create an appointment for tomorrow.
Patient patient = Firestarter.CreateFakePatients(docAndre, this.db, 1).Single();
Firestarter.CreateFakeAppointment(this.db, utcNow, docAndre, utcNow.AddDays(1.0), TimeSpan.FromMinutes(30.0), patient);
var workerMock = new Mock <EmailSenderWorker> {
CallBase = true
};
workerMock.Setup(w => w.CreateNewCerebelloEntities()).Returns(() =>
{
var db2 = CreateNewCerebelloEntities();
db2.SavingChanges += (e, s) => isDbChanged = true;
return(db2);
});
workerMock.Setup(w => w.GetUtcNow()).Returns(utcNow);
workerMock.Setup(w => w.GetWorkerType()).Returns(typeof(EmailSenderWorker));
workerMock.Setup(w => w.TrySendEmail(It.IsAny <MailMessage>())).Callback((MailMessage mm) => { mailMessage = mm; });
worker = workerMock.Object;
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
worker.RunOnce();
Assert.IsTrue(isDbChanged, "Database must be saved.");
Assert.IsNotNull(mailMessage, "mailMessage must have been sent.");
using (var db3 = CreateNewCerebelloEntities())
{
var appointment = db3.Appointments.Single();
Assert.IsTrue(appointment.ReminderEmailSent, "ReminderEmailSent flag must be set.");
}
}
public override void Initialize(EnemyBase enemy)
{
base.Initialize(enemy);
EnemyLayer = (1 << LayerMask.NameToLayer("Enemy"));
firestarter = enemy as Firestarter;
splashdamage = firestarter.SplashDamageProjectile;
splashrange = firestarter.SplashRangeProjectile;
//otherEnemies = GameObject.FindGameObjectsWithTag( "Enemy" );
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateEnter(animator, stateInfo, layerIndex);
animator.SetBool("isIdle", false);
animator.SetBool("isAlerting", false);
animator.SetBool("isChasing", false);
animator.SetBool("isAttacking", false);
Firestarter firestarter = EnemyBase as Firestarter;
firestarter.DoSplashDamage(firestarter.SplashDamageDeath, firestarter.SplashRangeDeath, firestarter.transform);
}
public void Create_1_HappyPath()
{
ExamsController controller;
Patient patient;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
patient = Firestarter.CreateFakePatients(doctor, this.db).First();
var mr = new MockRepository(true);
controller = mr.CreateController <ExamsController>();
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Creating a new examination request.
ActionResult actionResult;
{
var medicalProc = this.db.SYS_MedicalProcedure.Single(x => x.Code == "4.03.04.36-1");
var viewModel = new ExaminationRequestViewModel
{
PatientId = patient.Id,
Notes = "Any text",
MedicalProcedureId = medicalProc.Id,
MedicalProcedureName = "Hemograma com contagem de plaquetas ou frações (eritrograma, leucograma, plaquetas)",
};
actionResult = controller.Create(new[] { viewModel });
}
// Verifying the ActionResult.
Assert.IsNotNull(actionResult, "The result of the controller method is null.");
// Verifying the controller model-state.
Assert.IsTrue(controller.ModelState.IsValid, "ModelState is not valid.");
// Verifying the database.
Assert.IsTrue(this.db.ExaminationRequests.Any(x => x.PatientId == patient.Id), "Database record was not saved.");
// Verifying the database.
using (var db2 = DbTestBase.CreateNewCerebelloEntities())
{
var obj = db2.ExaminationRequests.FirstOrDefault(x => x.PatientId == patient.Id);
Assert.IsNotNull(obj, "Database record was not saved.");
Assert.AreEqual("Any text", obj.Text);
Assert.AreEqual("4.03.04.36-1", obj.MedicalProcedureCode);
Assert.AreEqual("Hemograma com contagem de plaquetas ou frações (eritrograma, leucograma, plaquetas)", obj.MedicalProcedureName);
}
}
public void Create_WithoutMedicalProcedure()
{
ExamsController controller;
Patient patient;
bool isDbChangesSaved = false;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
patient = Firestarter.CreateFakePatients(doctor, this.db).First();
var mr = new MockRepository(true);
controller = mr.CreateController <ExamsController>(
setupNewDb: db => db.SavingChanges += (s, e) => { isDbChangesSaved = true; });
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Creating a new examination request without the text.
// This is not allowed and must generate a model state validation message.
ActionResult actionResult;
ExaminationRequestViewModel viewModel;
{
viewModel = new ExaminationRequestViewModel
{
PatientId = patient.Id,
};
Mvc3TestHelper.SetModelStateErrors(controller, viewModel);
actionResult = controller.Create(new[] { viewModel });
}
// Verifying the ActionResult, and the DB.
// - The result must be a ViewResult, with the name "Edit".
// - The controller ModelState must have one validation message.
Assert.IsNotNull(actionResult, "The result of the controller method is null.");
Assert.IsInstanceOfType(actionResult, typeof(ViewResult));
var viewResult = (ViewResult)actionResult;
Assert.AreEqual("edit", viewResult.ViewName, ignoreCase: true);
Assert.IsFalse(controller.ModelState.IsValid, "ModelState should not be valid.");
Assert.AreEqual(
1,
controller.ModelState.GetPropertyErrors(() => viewModel.MedicalProcedureName).Count(),
"ModelState should contain one validation message.");
// Verifying the database: cannot save the changes.
Assert.IsFalse(isDbChangesSaved, "Database changes were saved, but they should not.");
}
public void MedicalCertificateFieldsEditor_4_BothParametersAreSuppliedAndTheyDontMatch()
{
// create a model
ModelMedicalCertificateViewModel certificateModelFormModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%PROP_1%>"
};
var mr = new MockRepository(true);
var certificateModelcontroller = mr.CreateController <ModelMedicalCertificatesController>();
certificateModelcontroller.Edit(certificateModelFormModel);
var modelId = this.db.ModelMedicalCertificates.Select(m => m.Id).First();
// create a certificate
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var controller = mr.CreateController <MedicalCertificatesController>();
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
// both EXISTING
ModelId = modelId,
PatientId = patientId,
Fields = new List <MedicalCertificateFieldViewModel>()
{
new MedicalCertificateFieldViewModel()
{
Name = "prop_1", Value = "Este é o valor"
}
}
};
// save the certificate
controller.Edit(new[] { formModel });
var certificateId = this.db.MedicalCertificates.Select(c => c.Id).First();
// at this point we have 2 certificate models, "modelId" and "anotherModelId" and we have a certificate using "modelId". The point is
// to call MedicalCertificateFieldsEditor passing "anotherModelId"
var controllerResult = controller.MedicalCertificateFieldsEditor(modelId, certificateId, null);
// obtaining the view-model
ViewResult view = (ViewResult)controllerResult;
var viewModel = (MedicalCertificateViewModel)view.Model;
Assert.AreEqual(1, viewModel.Fields.Count);
Assert.AreEqual("Este é o valor", viewModel.Fields[0].Value);
}
public void Delete_WhenTheresAnExamResult()
{
PatientsController controller;
int patientId;
Patient patient;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(doctor, this.db, 1);
// we now have 1 patient
patient = this.db.Patients.FirstOrDefault();
Assert.IsNotNull(patient);
patientId = patient.Id;
var examResult = new ExaminationResult()
{
MedicalProcedureCode = "mcode",
MedicalProcedureName = "mname",
PatientId = patientId,
CreatedOn = DateTime.UtcNow,
Text = "tudo deu certo",
PracticeId = doctor.PracticeId,
};
this.db.SYS_MedicalProcedure.AddObject(
new SYS_MedicalProcedure()
{
Code = "mcode",
Name = "mname"
});
this.db.ExaminationResults.AddObject(examResult);
this.db.SaveChanges();
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
controller.Delete(patientId);
// this patient must have been deleted
patient = this.db.Patients.FirstOrDefault(p => p.Id == patientId);
Assert.IsNull(patient);
}
public override void Damage(Character target, GameObject projectile)
{
Destroy(projectile);
if (!target.GetComponent <Firestarter>())
{
target.gameObject.AddComponent <Firestarter>();
}
Firestarter fireStarter = target.GetComponent <Firestarter>();
fireStarter.StartFire(target, burningColor, normalColor, damageTicks, damage, fireDuration);
}
public void Edit_HappyPath()
{
AnamnesesController controller;
AnamneseViewModel formModel;
try
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db, 1);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
formModel = new AnamneseViewModel()
{
PatientId = patientId,
Conclusion = "This is my anamnese",
DiagnosticHypotheses = new List <DiagnosticHypothesisViewModel>()
{
new DiagnosticHypothesisViewModel()
{
Text = "Text", Cid10Code = "Q878"
},
new DiagnosticHypothesisViewModel()
{
Text = "Text2", Cid10Code = "Q879"
}
}
};
var mr = new MockRepository(true);
controller = mr.CreateController <AnamnesesController>();
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
// executing the test
controller.Create(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
var anamneses = this.db.Anamnese.ToList();
var diagnosticHypotheses = this.db.DiagnosticHypotheses.ToList();
Assert.AreEqual(1, anamneses.Count);
Assert.AreEqual(2, diagnosticHypotheses.Count);
}
public void GetCertificateText_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patient = this.db.Patients.First();
var patientId = patient.Id;
var patientName = patient.Person.FullName;
// obtains a valid certificate model
ModelMedicalCertificateViewModel certificateModelFormModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%FIELD_1%>. This is the patient name: <%paCIENTE%>"
};
var mr = new MockRepository(true);
var certificateModelController = mr.CreateController <ModelMedicalCertificatesController>();
var certificateModelControllerResult = certificateModelController.Edit(certificateModelFormModel);
var modelId = this.db.ModelMedicalCertificates.First().Id;
// tries to save
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
// both EXISTING
ModelId = modelId,
PatientId = patientId,
Fields = new List <MedicalCertificateFieldViewModel>()
{
new MedicalCertificateFieldViewModel()
{
Name = "field_1", Value = "This is a value"
}
}
};
var certificateController = mr.CreateController <MedicalCertificatesController>();
var certificateControllerResult = certificateController.Edit(new[] { formModel });
Assert.IsInstanceOfType(certificateControllerResult, typeof(ViewResult));
Assert.AreEqual(true, certificateController.ModelState.IsValid);
// Now verifies whether the result is the expected
var newlyCreatedCertificate = this.db.MedicalCertificates.First();
var certificateText = certificateController.GetCertificateText(newlyCreatedCertificate.Id);
Assert.AreEqual("This is a reference: This is a value. This is the patient name: " + patientName, certificateText);
}
public void Delete_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
// obtains a valid certificate model
ModelMedicalCertificateViewModel certificateModelFormModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%FIELD_1%>"
};
var mr = new MockRepository(true);
var certificateModelController = mr.CreateController <ModelMedicalCertificatesController>();
var certificateModelControllerResult = certificateModelController.Edit(certificateModelFormModel);
var certificateModel = this.db.ModelMedicalCertificates.First();
// tries to save a certificate based on that model
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
ModelId = certificateModel.Id,
PatientId = patientId,
Fields = new List <MedicalCertificateFieldViewModel>()
{
new MedicalCertificateFieldViewModel()
{
Name = "field_1", Value = "value 1"
}
}
};
var certificateController = mr.CreateController <MedicalCertificatesController>();
var certificateControllerResult = certificateController.Edit(new[] { formModel });
var certificate = this.db.MedicalCertificates.First();
// tries to delete the certificate
var result = certificateController.Delete(certificate.Id);
JsonDeleteMessage deleteMessage = (JsonDeleteMessage)result.Data;
Assert.AreEqual(true, deleteMessage.success, "deleteMessage.success must be true");
Assert.AreEqual(0, this.db.MedicalCertificates.Count());
}
public void Delete_WhenTheresAnAnamnese()
{
PatientsController controller;
int patientId;
Patient patient;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(doctor, this.db, 1);
// we now have 1 patient
patient = this.db.Patients.FirstOrDefault();
Assert.IsNotNull(patient);
patientId = patient.Id;
// now, let's add an anamnese
var anamnese = new Anamnese()
{
PatientId = patientId,
CreatedOn = DateTime.UtcNow,
Conclusion = "This is my anamnese",
PracticeId = doctor.PracticeId,
};
patient.Anamneses.Add(anamnese);
this.db.SaveChanges();
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
controller.Delete(patientId);
// this patient must have been deleted
patient = this.db.Patients.FirstOrDefault(p => p.Id == patientId);
Assert.IsNull(patient);
}
public void Edit_WhenBothCid10AndNotesAreEmpty()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db, 1);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new DiagnosisViewModel
{
PatientId = patientId,
};
var mr = new MockRepository(true);
var controller = mr.CreateController <DiagnosisController>();
controller.Edit(new[] { formModel });
Assert.IsFalse(controller.ModelState.IsValid);
}
public void Delete_WhenTheresAnAppointment()
{
PatientsController controller;
Patient patient;
try
{
var docAndre = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(docAndre, this.db, 1);
// we now have 1 patient
patient = this.db.Patients.FirstOrDefault();
Assert.IsNotNull(patient);
var referenceTime = DateTime.UtcNow;
var appointment = new Appointment()
{
Doctor = docAndre,
CreatedBy = docAndre.Users.First(),
CreatedOn = referenceTime,
PatientId = patient.Id,
Start = referenceTime,
End = referenceTime + TimeSpan.FromMinutes(30),
PracticeId = docAndre.PracticeId,
};
this.db.Appointments.AddObject(appointment);
this.db.SaveChanges();
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
controller.Delete(patient.Id);
// this patient must have been deleted
patient = this.db.Patients.FirstOrDefault(p => p.Id == patient.Id);
Assert.IsNull(patient);
}
public void Delete_2_ExamThatDoesNotExist()
{
ExamsController controller;
bool isDbChangesSaved = false;
try
{
using (var db2 = DbTestBase.CreateNewCerebelloEntities())
{
Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(db2);
var mr = new MockRepository(true);
controller = mr.CreateController <ExamsController>(
setupNewDb: db => db.SavingChanges += (s, e) => { isDbChangesSaved = true; });
// Define André as the logged user, he cannot edit Marta's patients.
mr.SetCurrentUser_Andre_CorrectPassword();
}
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Editing an examination request that does not belong to the current user's practice.
// This is not allowed and must throw an exception.
// note: this is not a validation error, this is a malicious attack...
var jsonResult = controller.Delete(6327);
// Verifying the ActionResult.
Assert.IsNotNull(jsonResult, "The result of the controller method is null.");
var jsonDelete = (JsonDeleteMessage)jsonResult.Data;
Assert.IsFalse(jsonDelete.success, "Deletion should not succed.");
Assert.IsNotNull(jsonDelete.text, "Deletion should fail with a message.");
// Verifying the controller model-state.
Assert.IsTrue(controller.ModelState.IsValid, "ModelState is not valid.");
// Verifying the database: cannot save the changes.
Assert.IsFalse(isDbChangesSaved, "Database changes were saved, but they should not.");
}
public void Delete_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new AnamneseViewModel()
{
PatientId = patientId,
Conclusion = "This is my anamnese",
DiagnosticHypotheses = new List <DiagnosticHypothesisViewModel>()
{
new DiagnosticHypothesisViewModel()
{
Text = "Text", Cid10Code = "Q878"
},
new DiagnosticHypothesisViewModel()
{
Text = "Text2", Cid10Code = "Q879"
}
}
};
var mr = new MockRepository(true);
var controller = mr.CreateController <AnamnesesController>();
controller.Create(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
// get's the newly created anamnese
var newlyCreatedAnamnese = this.db.Anamnese.First();
// tries to delete the anamnese
var result = controller.Delete(newlyCreatedAnamnese.Id);
JsonDeleteMessage deleteMessage = (JsonDeleteMessage)result.Data;
Assert.AreEqual(true, deleteMessage.success);
Assert.AreEqual(0, this.db.Anamnese.Count());
}
public void Delete_WhenTheresADiagnosis()
{
PatientsController controller;
Patient patient;
try
{
var docAndre = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(docAndre, this.db, 1);
// we now have 1 patient
patient = this.db.Patients.FirstOrDefault();
Assert.IsNotNull(patient);
var referenceTime = DateTime.UtcNow;
var diagnosis = new Diagnosis()
{
CreatedOn = referenceTime,
PatientId = patient.Id,
Cid10Code = "QAA",
Cid10Name = "Doença X", // x-men!
PracticeId = docAndre.PracticeId,
};
this.db.Diagnoses.AddObject(diagnosis);
this.db.SaveChanges();
}
catch
{
Assert.Inconclusive("Test initialization has failed.");
return;
}
controller.Delete(patient.Id);
// this patient must have been deleted
patient = this.db.Patients.FirstOrDefault(p => p.Id == patient.Id);
Assert.IsNull(patient);
}
public void Edit_1_CannotSaveWithInvalidModelId()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
// this probably doesn't exist
ModelId = 9999,
PatientId = patientId
};
var mr = new MockRepository(true);
var controller = mr.CreateController <MedicalCertificatesController>();
var controllerResult = controller.Edit(new[] { formModel });
Assert.IsInstanceOfType(controllerResult, typeof(ViewResult));
Assert.AreEqual(false, controller.ModelState.IsValid);
Assert.AreEqual(1, controller.ModelState.Count);
}
public void Edit_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
// obtains a valid certificate model
var certificateModelFormModel = new ModelMedicalCertificateViewModel()
{
Name = "My Model",
Text = "This is a reference: <%FIELD_1%>"
};
var mr = new MockRepository(true);
var certificateModelTarget = mr.CreateController <ModelMedicalCertificatesController>();
var certificateModelResult = certificateModelTarget.Edit(certificateModelFormModel);
var modelId = this.db.ModelMedicalCertificates.First().Id;
// tries to save
MedicalCertificateViewModel formModel = new MedicalCertificateViewModel()
{
// both EXISTING
ModelId = modelId,
PatientId = patientId,
Fields = new List <MedicalCertificateFieldViewModel>()
{
new MedicalCertificateFieldViewModel()
{
Name = "field_1", Value = "Este é o valor"
}
}
};
var target = mr.CreateController <MedicalCertificatesController>();
var result = target.Edit(new[] { formModel });
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.AreEqual(true, target.ModelState.IsValid);
}
public void Search_ShouldReturnEverythingInEmptySearch()
{
PatientsController controller;
try
{
var doctor = Firestarter.Create_CrmMg_Psiquiatria_DrHouse_Andre(this.db);
var mr = new MockRepository(true);
controller = mr.CreateController <PatientsController>();
Firestarter.CreateFakePatients(doctor, this.db, 100);
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
var patientsCount = this.db.Patients.Count();
// making an empty search
var result = controller.Search(new Areas.App.Models.SearchModel()
{
Term = "",
Page = 1
});
var resultAsView = result as ViewResult;
Assert.IsNotNull(resultAsView);
var model = resultAsView.Model as SearchViewModel <PatientViewModel>;
Assert.IsNotNull(model);
Assert.AreEqual(100, model.Count);
Assert.AreEqual(Code.Constants.GRID_PAGE_SIZE, model.Objects.Count);
}