text: import os
  
  from datetime import datetime, timedelta
  
  from django.core.files.uploadedfile import SimpleUploadedFile
  from django.test import TestCase
  
  from symposion.conference.models import Conference, Section
  
  from ..forms import ScheduleSectionForm
  from ..models import Day, Room, Schedule, Slot, SlotKind
  
  DATA_DIR = os.path.join(os.path.dirname(__file__), "data")
  
  
  class ScheduleSectionFormTests(TestCase):
      def setUp(self):
          self.conference = Conference.objects.create(title="test")
          self.section = Section.objects.create(
              conference=self.conference, name="test"
          )
          self.schedule = Schedule.objects.create(section=self.section)
          self.today = datetime.now()
          self.tomorrow = self.today + timedelta(days=1)
  
      def test_clean_filename(self):
          """Ensure a file is provided if the submit action was utilized"""
          data = {"submit": "Submit"}
          form = ScheduleSectionForm(data=data, schedule=self.schedule)
          self.assertIn("filename", form.errors)
  
      def test_clean_filename_not_required(self):
          """Ensure file is not required if the delete action was utilize"""
          data = {"delete": "Delete"}
          form = ScheduleSectionForm(data=data, schedule=self.schedule)
          self.assertTrue(form.is_valid())
  
      def test_delete(self):
          """Delete schedule (Days) for supplied section"""
          Day.objects.create(schedule=self.schedule, date=self.today)
          Day.objects.create(schedule=self.schedule, date=self.tomorrow)
          other_section = Section.objects.create(
              conference=self.conference, name="other"
          )
          other_schedule = Schedule.objects.create(section=other_section)
          other_day = Day.objects.create(
              schedule=other_schedule, date=self.tomorrow
          )
          self.assertEqual(3, Day.objects.all().count())
          data = {"delete": "Delete"}
          form = ScheduleSectionForm(data=data, schedule=self.schedule)
          form.delete_schedule()
          days = Day.objects.all()
          self.assertEqual(1, days.count())
          self.assertIn(other_day, days)
  
      def test_build_days(self):
          """Test private method to build days based off ingested CSV"""
          form = ScheduleSectionForm(schedule=self.schedule)
          data = (
              {"date": datetime.strftime(self.today, "%m/%d/%Y")},
              {"date": datetime.strftime(self.today, "%m/%d/%Y")},
              {"date": datetime.strftime(self.tomorrow, "%m/%d/%Y")},
          )
          self.assertEqual(0, Day.objects.all().count())
          form._build_days(data)
          self.assertEqual(2, Day.objects.all().count())
  
      def test_build_days_malformed(self):
          """Test failure for malformed date in CSV"""
          form = ScheduleSectionForm(schedule=self.schedule)
          data = (
              {"date": datetime.strftime(self.today, "%m/%d/%Y")},
              {"date": "12-12-12"},
          )
          self.assertEqual(0, Day.objects.all().count())
          msg_type, msg = form._build_days(data)
          self.assertEqual(0, Day.objects.all().count())
          self.assertEqual(40, msg_type)
          self.assertIn("12-12-12", msg)
  
      def test_build_rooms(self):
          """Test private method to build rooms based off ingested CSV"""
          form = ScheduleSectionForm(schedule=self.schedule)
          data = ({"room": "foo"}, {"room": "bar"}, {"room": "foo"})
          self.assertEqual(0, Room.objects.all().count())
          form._build_rooms(data)
          self.assertEqual(2, Room.objects.all().count())
  
      def test_get_start_end_times(self):
          """
          Test private method to convert start and end times based off
          ingested CSV
          """
          form = ScheduleSectionForm(schedule=self.schedule)
          start = "2000-01-01T12:00:00+00:00"
          end = "2000-01-01T13:00:00+00:00"
          data = {"time_start": start, "time_end": end}
          start_time, end_time = form._get_start_end_times(data)
          self.assertEqual(start, start_time.isoformat())
          self.assertEqual(end, end_time.isoformat())
  
      def test_get_start_end_times_malformed(self):
          """
          Test private method for malformed time based off ingested CSV
          """
          form = ScheduleSectionForm(schedule=self.schedule)
          start = "12:00"
          end = "01:00"
          data = {"time_start": start, "time_end": end}
          msg_type, msg = form._get_start_end_times(data)
          self.assertEqual(40, msg_type)
          self.assertIn("Malformed", msg)
  
      def test_build_schedule(self):
          """
          Test successful schedule build based off ingested CSV
          """
          self.assertEqual(0, Day.objects.all().count())
          self.assertEqual(0, Room.objects.all().count())
          self.assertEqual(0, Slot.objects.all().count())
          self.assertEqual(0, SlotKind.objects.all().count())
          schedule_csv = open(os.path.join(DATA_DIR, "schedule.csv"), "rb")
          file_data = {
              "filename": SimpleUploadedFile(
                  schedule_csv.name, schedule_csv.read()
              )
          }
          data = {"submit": "Submit"}
          form = ScheduleSectionForm(data, file_data, schedule=self.schedule)
          form.is_valid()
          msg_type, msg = form.build_schedule()
          self.assertEqual(25, msg_type)
          self.assertIn("imported", msg)
          self.assertEqual(2, Day.objects.all().count())
          self.assertEqual(2, Room.objects.all().count())
          self.assertEqual(8, Slot.objects.all().count())
          self.assertEqual(2, SlotKind.objects.all().count())
  
      def test_build_schedule_overlap(self):
          """
          Test rolledback schedule build based off ingested CSV with Slot overlap
          """
          self.assertEqual(0, Day.objects.all().count())
          self.assertEqual(0, Room.objects.all().count())
          self.assertEqual(0, Slot.objects.all().count())
          self.assertEqual(0, SlotKind.objects.all().count())
          schedule_csv = open(
              os.path.join(DATA_DIR, "schedule_overlap.csv"), "rb"
          )
          file_data = {
              "filename": SimpleUploadedFile(
                  schedule_csv.name, schedule_csv.read()
              )
          }
          data = {"submit": "Submit"}
          form = ScheduleSectionForm(data, file_data, schedule=self.schedule)
          form.is_valid()
          msg_type, msg = form.build_schedule()
          self.assertEqual(40, msg_type)
          self.assertIn("overlap", msg)
          self.assertEqual(0, Day.objects.all().count())
          self.assertEqual(0, Room.objects.all().count())
          self.assertEqual(0, Slot.objects.all().count())
          self.assertEqual(0, SlotKind.objects.all().count())
  