Merge pull request #5127 from pfarestveit/calendly

BEA: add Calendly to appt tests

Author: johncrossman

bea/config/bea_test_base_configs.py

@@ -295,6 +295,10 @@ def set_test_students(self, count, opts=None):
                 app.logger.info('Running tests using students with appointments')
                 sids = nessie_utils.get_all_student_sids()
 
+                calendly_sids = nessie_timeline_utils.get_sids_with_calendly_appts()
+                calendly_sids = list(set(sids) & set(calendly_sids))
+                app.logger.info(f'There are {len(calendly_sids)} students with Calendly appointments')
+
                 sis_sids = nessie_timeline_utils.get_sids_with_sis_appts()
                 sis_sids = list(set(sids) & set(sis_sids))
                 app.logger.info(f'There are {len(sis_sids)} students with SIS appointments')
@@ -303,7 +307,7 @@ def set_test_students(self, count, opts=None):
                 ycbm_sids = list(set(sids) & set(ycbm_sids))
                 app.logger.info(f'There are {len(ycbm_sids)} students with YCBM appointments')
 
-                for sid_list in [sis_sids, ycbm_sids]:
+                for sid_list in [calendly_sids, sis_sids, ycbm_sids]:
                     random.shuffle(sid_list)
                     test_sids.extend(sid_list[:count])
 

bea/config/bea_test_config.py

@@ -47,7 +47,10 @@ def appts_content(self):
         # Generate test cases for parameterized tests
         for student in self.test_students:
             # Throw out junk SIS appts
-            appts = [a for a in nessie_timeline_utils.get_sis_appts(student) if '504GatewayTimeout' not in a.detail][0:limit]
+            appts = [a for a in nessie_timeline_utils.get_sis_appts(student) if '504GatewayTimeout' not in a.detail]
+            appts = appts[0:limit] if appts else []
+            calendly_appts = nessie_timeline_utils.get_calendly_appts(student)[0:limit]
+            appts.extend(calendly_appts)
             ycbm_appts = nessie_timeline_utils.get_ycbm_appts(student)[0:limit]
             appts.extend(ycbm_appts)
             for appt in appts:

bea/models/notes_and_appts/timeline_record_source.py

@@ -36,6 +36,10 @@ class TimelineRecordSource(Enum):
         'name': 'BOA',
         'schema': None,
     }
+    CALENDLY = {
+        'name': 'Calendly',
+        'schema': 'calendly_advising_appointments',
+    }
     DATA = {
         'name': 'Data Science',
         'schema': 'boac_advising_data_science',

bea/pages/student_page_timeline.py

@@ -147,7 +147,11 @@ def item_attachment_els(self, item):
 
     def item_attachment_el(self, item, attachment_name):
         for el in self.item_attachment_els(item):
-            if el.text.split('\n')[1].strip().lower() == attachment_name.lower():
+            if '\n' in el.text:
+                text = el.text.split('\n')[1]
+            else:
+                text = el.text
+            if text.strip().lower() == attachment_name.lower():
                 return el
 
     def download_attachment(self, item, attachment, student=None):

bea/test_utils/nessie_timeline_utils.py

@@ -402,6 +402,51 @@ def get_sis_notes(student):
 # APPOINTMENTS
 
 
+def get_calendly_appts(student):
+    sql = f"""SELECT boac_advising_appointments.calendly_advising_appointments.id,
+                     boac_advising_appointments.calendly_advising_appointments.title,
+                     boac_advising_appointments.calendly_advising_appointments.questions_and_answers,
+                     boac_advising_appointments.calendly_advising_appointments.host_name,
+                     boac_advising_appointments.calendly_advising_appointments.start_time,
+                     boac_advising_appointments.calendly_advising_appointments.end_time,
+                     boac_advising_appointments.calendly_advising_appointments.canceled_at,
+                     boac_advising_appointments.calendly_advising_appointments.canceled_by,
+                     boac_advising_appointments.calendly_advising_appointments.cancellation_reason,
+                     boac_advising_appointments.calendly_advising_appointments.is_rescheduled,
+                     boac_advising_appointments.calendly_advising_appointments.is_student_no_show
+                FROM boac_advising_appointments.calendly_advising_appointments
+               WHERE boac_advising_appointments.calendly_advising_appointments.student_sid = '{student.sid}'"""
+    app.logger.info(sql)
+    results = data_loch.safe_execute_rds(sql)
+    appts = []
+    for row in results:
+        advisor = User({'full_name': row['host_name']})
+        canceled = True if row['canceled_at'] else False
+        no_show = row['is_student_no_show']
+        rescheduled = row['is_rescheduled']
+        if no_show:
+            status = 'No Show'
+        elif rescheduled:
+            status = 'Rescheduled'
+        elif canceled:
+            status = 'Cancelled'
+        else:
+            status = None
+        appts.append(Appointment(data={
+            'record_id': row['id'],
+            'advisor': advisor,
+            'cancel_reason': row['cancellation_reason'],
+            'detail': row['questions_and_answers'],
+            'end_time': (row['end_time'] and utils.date_to_local_tz(row['end_time'])),
+            'source': TimelineRecordSource.CALENDLY,
+            'start_time': (row['start_time'] and utils.date_to_local_tz(row['start_time'])),
+            'status': status,
+            'student': student,
+            'title': re.sub(r'\s+', ' ', str(row['title'])).strip(),
+        }))
+    return appts
+
+
 def get_sis_appts(student):
     sql = f"""SELECT sis_advising_notes.advising_appointments.id AS id,
                      sis_advising_notes.advising_appointments.note_body AS body,
@@ -472,6 +517,7 @@ def get_sis_appts(student):
             if t['topic']:
                 topics.append(t['topic'].upper())
         topics.sort()
+        topics = list(set(topics))
 
         appts.append(Appointment(attachments=attachments,
                                  data=appt_data,
@@ -504,7 +550,6 @@ def get_ycbm_appts(student):
             'record_id': str(k),
             'advisor': advisor,
             'cancel_reason': cancel_reason,
-            'created_date': (v[0]['starts_at'] and utils.date_to_local_tz(v[0]['starts_at'])),
             'detail': v[0]['details'],
             'end_time': (v[0]['ends_at'] and utils.date_to_local_tz(v[0]['ends_at'])),
             'source': TimelineRecordSource.YCBM,
@@ -517,6 +562,15 @@ def get_ycbm_appts(student):
     return appts
 
 
+def get_sids_with_calendly_appts():
+    sql = """SELECT DISTINCT student_sid AS sid
+               FROM boac_advising_appointments.calendly_advising_appointments
+              WHERE student_uid IS NOT NULL"""
+    app.logger.info(sql)
+    results = data_loch.safe_execute_rds(sql)
+    return list(map(lambda r: str(r['sid']), results))
+
+
 def get_sids_with_sis_appts():
     sql = """SELECT DISTINCT sis_advising_notes.advising_appointments.sid
                FROM sis_advising_notes.advising_appointments

bea/tests/test_appt_content.py

@@ -60,7 +60,8 @@ def test_load_student_page(self, student):
     def test_appt_sort_order(self, student):
         appts = nessie_timeline_utils.get_sis_appts(student)
         appts.extend(nessie_timeline_utils.get_ycbm_appts(student))
-        appts.sort(key=lambda ap: [ap.created_date, ap.record_id], reverse=True)
+        appts.extend(nessie_timeline_utils.get_calendly_appts(student))
+        appts.sort(key=lambda ap: [(ap.created_date or ap.start_time), ap.record_id], reverse=True)
         expected_ids = [a.record_id for a in appts]
         visible_ids = self.student_page.visible_appt_ids()
         utils.assert_equivalence(visible_ids, expected_ids)
@@ -79,7 +80,7 @@ def test_load_student_page(self, tc):
 
     def test_collapsed_detail(self, tc):
         visible = self.student_page.collapsed_appt_detail(tc.appt)
-        if tc.appt.source == TimelineRecordSource.YCBM:
+        if tc.appt.source in [TimelineRecordSource.CALENDLY, TimelineRecordSource.YCBM]:
             assert tc.appt.title
             utils.assert_equivalence(visible, tc.appt.title)
         elif tc.appt.source == TimelineRecordSource.SIS:
@@ -90,15 +91,14 @@ def test_collapsed_detail(self, tc):
                 utils.assert_actual_includes_expected(visible, placeholder)
 
     def test_collapsed_status(self, tc):
-        if tc.appt.status == 'Canceled':
-            utils.assert_equivalence(self.student_page.collapsed_appt_status(tc.appt), 'CANCELED')
+        if tc.appt.status:
+            utils.assert_equivalence(self.student_page.collapsed_appt_status(tc.appt), tc.appt.status.upper())
 
     def test_collapsed_date(self, tc):
         if tc.appt.source == TimelineRecordSource.SIS:
-            assert tc.appt.updated_date
             expected = self.student_page.expected_item_short_date_format(tc.appt.updated_date)
         else:
-            expected = self.student_page.expected_item_short_date_format(tc.appt.created_date)
+            expected = self.student_page.expected_item_short_date_format(tc.appt.start_time)
         utils.assert_actual_includes_expected(self.student_page.collapsed_appt_date(tc.appt), expected)
 
     def test_expanded_details(self, tc):
@@ -107,21 +107,18 @@ def test_expanded_details(self, tc):
             assert self.student_page.expanded_appt_details(tc.appt)
 
     def test_expanded_date(self, tc):
-        assert tc.appt.created_date
-        expected = self.student_page.expected_item_short_date_format(tc.appt.created_date)
+        if tc.appt.source == TimelineRecordSource.SIS:
+            expected = self.student_page.expected_item_short_date_format(tc.appt.created_date)
+        else:
+            expected = self.student_page.expected_item_short_date_format(tc.appt.start_time)
         utils.assert_equivalence(self.student_page.expanded_appt_date(tc.appt), expected)
 
     def test_expanded_times(self, tc):
-        if tc.appt.source == TimelineRecordSource.YCBM:
-            assert tc.appt.start_time
-            assert tc.appt.end_time
+        if tc.appt.source in [TimelineRecordSource.CALENDLY, TimelineRecordSource.YCBM]:
             start = datetime.datetime.strftime(tc.appt.start_time, '%-l:%M %p')
             end = datetime.datetime.strftime(tc.appt.end_time, '%-l:%M %p')
             utils.assert_actual_includes_expected(self.student_page.expanded_appt_time_range(tc.appt),
                                                   f'{start} - {end}')
-        else:
-            assert not tc.appt.start_time
-            assert not tc.appt.end_time
 
     def test_expanded_advisor(self, tc):
         # Appts have varying amounts of advisor info, just verify something's there
@@ -131,7 +128,7 @@ def test_expanded_advisor(self, tc):
         elif tc.appt.advisor.last_name:
             assert visible
 
-    def test_expanded_cancellation(self, tc):
+    def test_expanded_status(self, tc):
         visible = self.student_page.expanded_appt_cancel_reason(tc.appt)
         if tc.appt.status == 'Canceled' and tc.appt.cancel_reason:
             actual = re.sub(r'\W', '', visible)
@@ -143,7 +140,9 @@ def test_expanded_cancellation(self, tc):
     def test_expanded_contact_type(self, tc):
         visible = self.student_page.expanded_appt_type(tc.appt)
         if tc.appt.contact_type and tc.appt.contact_type != 'None':
-            utils.assert_equivalence(visible, tc.appt.contact_type)
+            utils.assert_actual_includes_expected(visible, tc.appt.contact_type)
+        elif tc.appt.source == TimelineRecordSource.CALENDLY:
+            utils.assert_actual_includes_expected(visible, TimelineRecordSource.CALENDLY.value['name'])
         else:
             assert not visible
 
@@ -170,13 +169,14 @@ def test_expanded_attachments(self, tc):
                     self.student_page.download_attachment(tc.appt, attach, tc.student)
 
     def test_appt_search(self, tc):
-        search_string = boa_utils.generate_appt_search_query(tc.appt)
-        if search_string:
-            self.student_page.show_appts()
-            self.student_page.clear_timeline_appt_search()
-            appt_count = len(self.student_page.visible_appt_ids())
-            self.student_page.search_within_timeline_appts(search_string)
-            results = self.student_page.visible_appt_ids()
-            utils.assert_actual_includes_expected(results, tc.appt.record_id)
-            if appt_count > 1:
-                assert len(results) < appt_count
+        if tc.appt.source != TimelineRecordSource.CALENDLY:
+            search_string = boa_utils.generate_appt_search_query(tc.appt)
+            if search_string:
+                self.student_page.show_appts()
+                self.student_page.clear_timeline_appt_search()
+                appt_count = len(self.student_page.visible_appt_ids())
+                self.student_page.search_within_timeline_appts(search_string)
+                results = self.student_page.visible_appt_ids()
+                utils.assert_actual_includes_expected(results, tc.appt.record_id)
+                if appt_count > 1:
+                    assert len(results) < appt_count

bea/tests/test_search_appt.py

@@ -36,7 +36,7 @@
 test.search_appts()
 
 
-# NB: YCBM appointments are *not* searchable
+# NB: Calendly and YCBM appointments are *not* searchable
 
 
 @pytest.mark.usefixtures('page_objects')