public void UpdateDoctorTest()
        {
            var dataStorage = new OfflineDataStorage();

            var doctorToUpdate = dataStorage.GetDoctors().Last();

            doctorToUpdate.Name = "QWERTY";

            dataStorage.UpdateDoctor(doctorToUpdate);
            Assert.AreEqual("QWERTY", dataStorage.GetDoctors().Last().Name);
        }
        public void UpdatePatientTest()
        {
            var dataStorage = new OfflineDataStorage();

            var patientToUpdate = dataStorage.GetPatients().Last();

            patientToUpdate.Name = "QWERTY";

            dataStorage.UpdatePatient(patientToUpdate);
            Assert.AreEqual("QWERTY", dataStorage.GetPatients().Last().Name);
        }
        public void DeleteAppointmentTest()
        {
            var dataStorage      = new OfflineDataStorage();
            int appointmentCount = dataStorage.GetAppointments().Count();
            var appToDelete      = dataStorage.GetAppointments().ElementAt(0);

            dataStorage.DeleteAppointment(appToDelete);

            var appointmentsAfterDelete = dataStorage.GetAppointments();

            Assert.AreEqual(appointmentCount - 1, appointmentsAfterDelete.Count());
            CollectionAssert.DoesNotContain(appointmentsAfterDelete.ToList(), appToDelete);
        }
        public void DeleteDoctorTest()
        {
            var dataStorage = new OfflineDataStorage();
            int count       = dataStorage.GetDoctors().Count();
            var docToDelete = dataStorage.GetDoctors().First();

            dataStorage.DeleteDoctor(docToDelete);

            var doctorsAfterDelete = dataStorage.GetDoctors();

            Assert.AreEqual(count - 1, doctorsAfterDelete.Count());
            CollectionAssert.DoesNotContain(doctorsAfterDelete.ToList(), docToDelete);
        }
        public void DeletePatientTest()
        {
            var dataStorage = new OfflineDataStorage();
            int count       = dataStorage.GetPatients().Count();
            var patToDelete = dataStorage.GetPatients().First();

            dataStorage.DeletePatient(patToDelete);

            var patientsAfterDelete = dataStorage.GetPatients();

            Assert.AreEqual(count - 1, patientsAfterDelete.Count());
            CollectionAssert.DoesNotContain(patientsAfterDelete.ToList(), patToDelete);
        }
        public void CreatePatientTest()
        {
            var dataStorage = new OfflineDataStorage();
            int count       = dataStorage.GetPatients().Count();
            var patient     = new Patient {
                Name = "ABC", Weight = 50, Height = 150
            };

            dataStorage.CreatePatient(patient);
            var patientsAfterCreate = dataStorage.GetPatients();

            Assert.AreEqual(count + 1, patientsAfterCreate.Count());
            Assert.AreEqual(patient, patientsAfterCreate.FirstOrDefault(p => p.Id == patient.Id));
        }
        public void CreateDoctorTest()
        {
            var dataStorage = new OfflineDataStorage();
            int count       = dataStorage.GetDoctors().Count();
            var doctor      = new Doctor {
                Name = "ABC"
            };

            dataStorage.CreateDoctor(doctor);
            var doctorsAfterCreate = dataStorage.GetDoctors();

            Assert.AreEqual(count + 1, doctorsAfterCreate.Count());
            Assert.AreEqual(doctor, doctorsAfterCreate.FirstOrDefault(d => d.Id == doctor.Id));
        }
        public void UpdateAppointmentTest()
        {
            var dataStorage = new OfflineDataStorage();
            var doctor      = new Doctor {
                Name = "A"
            };
            var appToUpdate = dataStorage.GetAppointments().ElementAt(0);

            appToUpdate.Doctor = doctor;
            dataStorage.UpdateAppointment(appToUpdate);

            var appAfterUpdate = dataStorage.GetAppointment(appToUpdate.Id);

            Assert.AreEqual(appAfterUpdate.Doctor.Name, doctor.Name);
        }
        public void CreateAppointmentTest()
        {
            var dataStorage = new OfflineDataStorage();
            var count       = dataStorage.GetAppointments().Count();
            var patient     = dataStorage.GetPatients().First();
            var doctor      = dataStorage.GetDoctors().First();

            var time        = DateTime.Now.AddHours(1);
            var appointment = new Appointment
            {
                Patient = patient,
                Doctor  = doctor,
                Start   = time,
                End     = time.AddMinutes(15)
            };

            dataStorage.CreateAppointment(appointment);

            var appointmentsAfterCreate = dataStorage.GetAppointments().ToList();

            Assert.AreEqual(count + 1, appointmentsAfterCreate.Count());
            CollectionAssert.Contains(appointmentsAfterCreate, appointment);
        }