示例#1
0
class VisitImportTestCase(TestCase):
    fixtures = ['patients.json', 'clinics.json', 'visits.json',]
    
    def setUp(self):
        self.clinic = Clinic.objects.get(te_id='01')
        self.importer = Importer()
        self.user = User.objects.get(username='******')
    
    def testInvalidImport(self):
        """attempt import of an invalid record"""
        self.assertRaises(Patient.DoesNotExist,         # exception
            self.importer.update_local_coming_visit,    # callback
            self.user,                                  # args
            self.clinic,                                
            create_instance(                            
                ComingVisit, {
                'key_id': '123456789', 
                'te_id': '01-1245', 
                'scheduled_visit_date':'2080-26 00:00:00'
            })
        )
    
    def testNewVisit(self):
        """import a new visit"""
        visit = self.importer.update_local_coming_visit(
            self.user,
            self.clinic,
            create_instance(ComingVisit, {
                'key_id': '02-123456789', 
                'te_id': '01-12345', 
                'scheduled_visit_date': '2100-06-01 00:00:00'
            })
        )
        visit = reload_record(visit)
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Created')
        self.assertEquals(visit.te_visit_id, '02-123456789')
        self.assertEquals(visit.patient.te_id, '01-12345')
        self.assertEquals(visit.date, date(2100, 6, 1))
    
    def testIndicateReschedule(self):
        """reschedule a visit"""
        missed_future_date = date(2200,5,1)
        # make sure we have a visit to reschedule
        original_visit = Visit.objects.get(te_visit_id='01-123456789')
        # make sure the updated date is actually in the future
        self.assertTrue(original_visit.date < missed_future_date)
        visit = self.importer.update_local_missed_visit(
            self.user,
            self.clinic,
            create_instance(MissedVisit, {
                'key_id': '01-123456789', 
                'te_id': '01-12345', 
                'missed_date': '%s 00:00:00' % missed_future_date # future date should be seen as a reschedule
            })
        )
        visit = reload_record(visit)
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Changed')
        self.assertEquals(visit.status, 'r')
        self.assertEquals(visit.date, date(2200, 5, 1))
    
    def testIndicateMissed(self):
        """indicate a missed visit"""
        visit = self.importer.update_local_missed_visit(
            self.user,
            self.clinic, 
            create_instance(MissedVisit, {
                'key_id': '01-123456799', 
                'te_id': '01-12345', 
                'missed_date': date.today().strftime('%Y-%m-%d 00:00:00')
            })
        )
        visit = reload_record(visit)
        # event = importMissedVisit(self.event, self.clinic, {'key_id':'01-123456789', 'te_id':'01-12345', 'missed_date':'2100-06-01 00:00:00'})
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Created')
        self.assertEquals(visit.status, 'm')
        self.assertEquals(visit.date, date.today())
    
    def testIndicateAttended(self):
        """indicate an attended visit"""
        visit = self.importer.update_local_done_visit(
            self.user,
            self.clinic, 
            create_instance(DoneVisit, {
                'key_id': '01-123456789', 
                'te_id': '01-12345', 
                'done_date': '2100-07-01 00:00:00'
            })
        )
        visit = reload_record(visit)
        self.assertEquals(visit.history.latest().get_history_type_display(),
                            'Changed')
        self.assertEquals(visit.status, 'a')
        self.assertEquals(visit.date, date(2100, 7, 1))
    
    def testIndicateNewAttended(self):
        """indicate a new attended visit"""
        visit = self.importer.update_local_done_visit(
            self.user,
            self.clinic,
            create_instance(DoneVisit, {
                'key_id': '02-123456789', 
                'te_id': '01-12345', 
                'done_date': '2100-07-01 00:00:00'
            })
        )
        visit = reload_record(visit)
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Created')
        self.assertEquals(visit.status, 'a')
        self.assertEquals(visit.date, date(2100, 7, 1))
    
    def testIndicateNewMissed(self):
        # indicate a new attended visit
        yesterday = date.today() - timedelta(days=1)
        visit = self.importer.update_local_missed_visit(
            self.user,
            self.clinic,
            create_instance(MissedVisit, {
                'key_id': '02-123456789', 
                'te_id': '01-12345', 
                'missed_date': yesterday.strftime('%Y-%m-%d 00:00:00')
            })
        )
        visit = reload_record(visit)
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Created')
        self.assertEquals(visit.status, 'm')
        self.assertEquals(visit.date, yesterday)
    
    def testDelete(self):
        """delete a visit"""
        visit = self.importer.update_local_deleted_visit(self.user, create_instance(DeletedVisit, {
            'key_id': '01-123456789', 
            'te_id': '01-12345'
        }))
        
        self.assertEqual(visit.deleted, True)
        self.assertEqual(visit.history.latest().get_history_type_display(), 
                            'Changed')          # it is Changed because of the soft delete
        self.assertRaises(Visit.DoesNotExist,   # exception
                            Visit.objects.get,  # callback
                            pk=visit.pk         # args
                        )